drive: Use ResourceMetadataStorage from FileCache

chrome/browser/chromeos/drive/file_cache.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 <vector>
 
 #include "base/file_util.h"
 #include "base/files/file_enumerator.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
 #include "base/task_runner_util.h"
 #include "chrome/browser/chromeos/drive/drive.pb.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/google_apis/task_util.h"
 #include "chromeos/chromeos_constants.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 namespace drive {
 namespace internal {
 namespace {
 
 // Name of the cache metadata DB.
-const base::FilePath::CharType* kCacheMetadataDBName =
+const base::FilePath::CharType kCacheMetadataDBName[] =
     FILE_PATH_LITERAL("cache_metadata.db");
 
 typedef std::map<std::string, FileCacheEntry> CacheMap;
 
 // Returns true if |md5| matches the one in |cache_entry| with some
 // exceptions. See the function definition for details.
 bool CheckIfMd5Matches(const std::string& md5,
                        const FileCacheEntry& cache_entry) {
   if (cache_entry.is_dirty()) {
     // If the entry is dirty, its MD5 may have been replaced by "local"
@@ skipping 111 matching lines @@
 void RunGetCacheEntryCallback(const GetCacheEntryCallback& callback,
                               FileCacheEntry* cache_entry,
                               bool success) {
   DCHECK(cache_entry);
   DCHECK(!callback.is_null());
   callback.Run(success, *cache_entry);
 }
 
 }  // namespace
 
-FileCache::FileCache(const base::FilePath& metadata_directory,
+FileCache::FileCache(ResourceMetadataStorage* storage,
                      const base::FilePath& cache_file_directory,
                      base::SequencedTaskRunner* blocking_task_runner,
                      FreeDiskSpaceGetterInterface* free_disk_space_getter)
-    : metadata_directory_(metadata_directory),
-      cache_file_directory_(cache_file_directory),
+    : cache_file_directory_(cache_file_directory),
       blocking_task_runner_(blocking_task_runner),
+      storage_(storage),
       free_disk_space_getter_(free_disk_space_getter),
       weak_ptr_factory_(this) {
   DCHECK(blocking_task_runner_.get());
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 FileCache::~FileCache() {
   // Must be on the sequenced worker pool, as |metadata_| must be deleted on
   // the sequenced worker pool.
   AssertOnSequencedWorkerPool();
@@ skipping 43 matching lines @@
                  cache_entry),
       base::Bind(
           &RunGetCacheEntryCallback, callback, base::Owned(cache_entry)));
 }
 
 bool FileCache::GetCacheEntry(const std::string& resource_id,
                               const std::string& md5,
                               FileCacheEntry* entry) {
   DCHECK(entry);
   AssertOnSequencedWorkerPool();
-  return metadata_->GetCacheEntry(resource_id, entry) &&
+  return storage_->GetCacheEntry(resource_id, entry) &&
       CheckIfMd5Matches(md5, *entry);
 }
 
 void FileCache::IterateOnUIThread(
     const CacheIterateCallback& iteration_callback,
     const base::Closure& completion_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!iteration_callback.is_null());
   DCHECK(!completion_callback.is_null());
 
   blocking_task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&FileCache::Iterate,
                  base::Unretained(this),
                  google_apis::CreateRelayCallback(iteration_callback)),
       completion_callback);
 }
 
 void FileCache::Iterate(const CacheIterateCallback& iteration_callback) {
   AssertOnSequencedWorkerPool();
   DCHECK(!iteration_callback.is_null());
 
-  scoped_ptr<FileCacheMetadata::Iterator> it = metadata_->GetIterator();
+  scoped_ptr<ResourceMetadataStorage::CacheEntryIterator> it =
+      storage_->GetCacheEntryIterator();
   for (; !it->IsAtEnd(); it->Advance())
-    iteration_callback.Run(it->GetKey(), it->GetValue());
+    iteration_callback.Run(it->GetID(), it->GetValue());
   DCHECK(!it->HasError());
 }
 
 void FileCache::FreeDiskSpaceIfNeededForOnUIThread(
     int64 num_bytes,
     const InitializeCacheCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&FileCache::FreeDiskSpaceIfNeededFor,
                  base::Unretained(this),
                  num_bytes),
       callback);
 }
 
 bool FileCache::FreeDiskSpaceIfNeededFor(int64 num_bytes) {
   AssertOnSequencedWorkerPool();
 
   // Do nothing and return if we have enough space.
   if (HasEnoughSpaceFor(num_bytes, cache_file_directory_))
     return true;
 
   // Otherwise, try to free up the disk space.
   DVLOG(1) << "Freeing up disk space for " << num_bytes;
 
   // Remove all entries unless specially marked.
-  scoped_ptr<FileCacheMetadata::Iterator> it = metadata_->GetIterator();
+  scoped_ptr<ResourceMetadataStorage::CacheEntryIterator> it =
+      storage_->GetCacheEntryIterator();
   for (; !it->IsAtEnd(); it->Advance()) {
     const FileCacheEntry& entry = it->GetValue();
     if (!entry.is_pinned() &&
         !entry.is_dirty() &&
-        !mounted_files_.count(it->GetKey()))
-      metadata_->RemoveCacheEntry(it->GetKey());
+        !mounted_files_.count(it->GetID()))
+      storage_->RemoveCacheEntry(it->GetID());
   }
   DCHECK(!it->HasError());
 
   // Remove all files which have no corresponding cache entries.
   base::FileEnumerator enumerator(cache_file_directory_,
                                   false,  // not recursive
                                   base::FileEnumerator::FILES);
   std::string resource_id;
   std::string md5;
   FileCacheEntry entry;
@@ skipping 81 matching lines @@
       blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&FileCache::Pin, base::Unretained(this), resource_id),
       callback);
 }
 
 FileError FileCache::Pin(const std::string& resource_id) {
   AssertOnSequencedWorkerPool();
 
   FileCacheEntry cache_entry;
-  metadata_->GetCacheEntry(resource_id, &cache_entry);
+  storage_->GetCacheEntry(resource_id, &cache_entry);
   cache_entry.set_is_pinned(true);
-  metadata_->AddOrUpdateCacheEntry(resource_id, cache_entry);
+  storage_->PutCacheEntry(resource_id, cache_entry);
   return FILE_ERROR_OK;
 }
 
 void FileCache::UnpinOnUIThread(const std::string& resource_id,
                                 const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&FileCache::Unpin, base::Unretained(this), resource_id),
       callback);
 }
 
 FileError FileCache::Unpin(const std::string& resource_id) {
   AssertOnSequencedWorkerPool();
 
   // Unpinning a file means its entry must exist in cache.
   FileCacheEntry cache_entry;
-  if (!metadata_->GetCacheEntry(resource_id, &cache_entry))
+  if (!storage_->GetCacheEntry(resource_id, &cache_entry))
     return FILE_ERROR_NOT_FOUND;
 
   // Now that file operations have completed, update metadata.
   if (cache_entry.is_present()) {
     cache_entry.set_is_pinned(false);
-    metadata_->AddOrUpdateCacheEntry(resource_id, cache_entry);
+    storage_->PutCacheEntry(resource_id, cache_entry);
   } else {
     // Remove the existing entry if we are unpinning a non-present file.
-    metadata_->RemoveCacheEntry(resource_id);
+    storage_->RemoveCacheEntry(resource_id);
   }
 
   // Now it's a chance to free up space if needed.
   FreeDiskSpaceIfNeededFor(0);
 
   return FILE_ERROR_OK;
 }
 
 void FileCache::MarkAsMountedOnUIThread(
     const std::string& resource_id,
@@ skipping 46 matching lines @@
   AssertOnSequencedWorkerPool();
 
   // If file has already been marked dirty in previous instance of chrome, we
   // would have lost the md5 info during cache initialization, because the file
   // would have been renamed to .local extension.
   // So, search for entry in cache without comparing md5.
 
   // Marking a file dirty means its entry and actual file blob must exist in
   // cache.
   FileCacheEntry cache_entry;
-  if (!metadata_->GetCacheEntry(resource_id, &cache_entry) ||
+  if (!storage_->GetCacheEntry(resource_id, &cache_entry) ||
       !cache_entry.is_present()) {
     LOG(WARNING) << "Can't mark dirty a file that wasn't cached: res_id="
                  << resource_id
                  << ", md5=" << md5;
     return FILE_ERROR_NOT_FOUND;
   }
 
   if (cache_entry.is_dirty())
     return FILE_ERROR_OK;
 
   // Get the current path of the file in cache.
   base::FilePath source_path = GetCacheFilePath(resource_id, md5,
                                                 CACHED_FILE_FROM_SERVER);
   // Determine destination path.
   base::FilePath cache_file_path = GetCacheFilePath(
       resource_id, md5, CACHED_FILE_LOCALLY_MODIFIED);
 
   if (!MoveFile(source_path, cache_file_path))
     return FILE_ERROR_FAILED;
 
   // Now that file operations have completed, update metadata.
   cache_entry.set_md5(md5);
   cache_entry.set_is_dirty(true);
-  metadata_->AddOrUpdateCacheEntry(resource_id, cache_entry);
+  storage_->PutCacheEntry(resource_id, cache_entry);
   return FILE_ERROR_OK;
 }
 
 FileError FileCache::ClearDirty(const std::string& resource_id,
                                 const std::string& md5) {
   AssertOnSequencedWorkerPool();
 
   // |md5| is the new .<md5> extension to rename the file to.
   // So, search for entry in cache without comparing md5.
   FileCacheEntry cache_entry;
 
   // Clearing a dirty file means its entry and actual file blob must exist in
   // cache.
-  if (!metadata_->GetCacheEntry(resource_id, &cache_entry) ||
+  if (!storage_->GetCacheEntry(resource_id, &cache_entry) ||
       !cache_entry.is_present()) {
     LOG(WARNING) << "Can't clear dirty state of a file that wasn't cached: "
                  << "res_id=" << resource_id
                  << ", md5=" << md5;
     return FILE_ERROR_NOT_FOUND;
   }
 
   // If a file is not dirty (it should have been marked dirty via
   // MarkDirtyInCache), clearing its dirty state is an invalid operation.
   if (!cache_entry.is_dirty()) {
     LOG(WARNING) << "Can't clear dirty state of a non-dirty file: res_id="
                  << resource_id
                  << ", md5=" << md5;
     return FILE_ERROR_INVALID_OPERATION;
   }
 
   base::FilePath source_path = GetCacheFilePath(resource_id, md5,
                                                 CACHED_FILE_LOCALLY_MODIFIED);
   base::FilePath dest_path = GetCacheFilePath(resource_id, md5,
                                               CACHED_FILE_FROM_SERVER);
   if (!MoveFile(source_path, dest_path))
     return FILE_ERROR_FAILED;
 
   // Now that file operations have completed, update metadata.
   cache_entry.set_md5(md5);
   cache_entry.set_is_dirty(false);
-  metadata_->AddOrUpdateCacheEntry(resource_id, cache_entry);
+  storage_->PutCacheEntry(resource_id, cache_entry);
   return FILE_ERROR_OK;
 }
 
 void FileCache::RemoveOnUIThread(const std::string& resource_id,
                                  const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&FileCache::Remove, base::Unretained(this), resource_id),
       callback);
 }
 
 FileError FileCache::Remove(const std::string& resource_id) {
   AssertOnSequencedWorkerPool();
 
   // MD5 is not passed into RemoveCacheEntry because we would delete all
   // cache files corresponding to <resource_id> regardless of the md5.
   // So, search for entry in cache without taking md5 into account.
   FileCacheEntry cache_entry;
 
   // If entry doesn't exist, nothing to do.
-  if (!metadata_->GetCacheEntry(resource_id, &cache_entry))
+  if (!storage_->GetCacheEntry(resource_id, &cache_entry))
     return FILE_ERROR_OK;
 
   // Cannot delete a dirty or mounted file.
   if (cache_entry.is_dirty() || mounted_files_.count(resource_id))
     return FILE_ERROR_IN_USE;
 
   // Delete files that match "<resource_id>.*" unless modified locally.
   base::FilePath path_to_delete = GetCacheFilePath(resource_id, util::kWildCard,
                                                    CACHED_FILE_FROM_SERVER);
   base::FilePath path_to_keep = GetCacheFilePath(resource_id, std::string(),
                                                  CACHED_FILE_LOCALLY_MODIFIED);
   DeleteFilesSelectively(path_to_delete, path_to_keep);
 
   // Now that all file operations have completed, remove from metadata.
-  metadata_->RemoveCacheEntry(resource_id);
+  storage_->RemoveCacheEntry(resource_id);
 
   return FILE_ERROR_OK;
 }
 
 void FileCache::ClearAllOnUIThread(const InitializeCacheCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&FileCache::ClearAll, base::Unretained(this)),
       callback);
 }
 
 bool FileCache::Initialize() {
   AssertOnSequencedWorkerPool();
 
-  metadata_.reset(new FileCacheMetadata(blocking_task_runner_.get()));
-
-  const base::FilePath db_path =
-      metadata_directory_.Append(kCacheMetadataDBName);
-  switch (metadata_->Initialize(db_path)) {
-    case FileCacheMetadata::INITIALIZE_FAILED:
-      return false;
-
-    case FileCacheMetadata::INITIALIZE_OPENED:  // Do nothing.
-      break;
-
-    case FileCacheMetadata::INITIALIZE_CREATED: {
-      CacheMap cache_map;
-      ScanCacheDirectory(cache_file_directory_, &cache_map);
-      for (CacheMap::const_iterator it = cache_map.begin();
-           it != cache_map.end(); ++it) {
-        metadata_->AddOrUpdateCacheEntry(it->first, it->second);
-      }
-      break;
+  if (!ImportOldDB(storage_->directory_path().Append(kCacheMetadataDBName)) &&
+      !storage_->opened_existing_db()) {
+    CacheMap cache_map;
+    ScanCacheDirectory(cache_file_directory_, &cache_map);
+    for (CacheMap::const_iterator it = cache_map.begin();
+         it != cache_map.end(); ++it) {
+      storage_->PutCacheEntry(it->first, it->second);
     }
   }
   return true;
 }
 
 void FileCache::Destroy() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Invalidate the weak pointer.
   weak_ptr_factory_.InvalidateWeakPtrs();
@@ skipping 21 matching lines @@
   if (file_operation_type == FILE_OPERATION_COPY) {
     if (!file_util::GetFileSize(source_path, &file_size)) {
       LOG(WARNING) << "Couldn't get file size for: " << source_path.value();
       return FILE_ERROR_FAILED;
     }
   }
   if (!FreeDiskSpaceIfNeededFor(file_size))
     return FILE_ERROR_NO_SPACE;
 
   FileCacheEntry cache_entry;
-  metadata_->GetCacheEntry(resource_id, &cache_entry);
+  storage_->GetCacheEntry(resource_id, &cache_entry);
 
   // If file is dirty or mounted, return error.
   if (cache_entry.is_dirty() || mounted_files_.count(resource_id))
     return FILE_ERROR_IN_USE;
 
   base::FilePath dest_path = GetCacheFilePath(resource_id, md5,
                                               CACHED_FILE_FROM_SERVER);
   bool success = false;
   switch (file_operation_type) {
     case FILE_OPERATION_MOVE:
@@ skipping 26 matching lines @@
   }
 
   // Delete files that match |stale_filenames_pattern| except for |dest_path|.
   DeleteFilesSelectively(stale_filenames_pattern, dest_path);
 
   if (success) {
     // Now that file operations have completed, update metadata.
     cache_entry.set_md5(md5);
     cache_entry.set_is_present(true);
     cache_entry.set_is_dirty(false);
-    metadata_->AddOrUpdateCacheEntry(resource_id, cache_entry);
+    storage_->PutCacheEntry(resource_id, cache_entry);
   }
 
   return success ? FILE_ERROR_OK : FILE_ERROR_FAILED;
 }
 
 FileError FileCache::MarkAsMounted(const std::string& resource_id,
                                    base::FilePath* cache_file_path) {
   AssertOnSequencedWorkerPool();
   DCHECK(cache_file_path);
 
   // Get cache entry associated with the resource_id and md5
   FileCacheEntry cache_entry;
-  if (!metadata_->GetCacheEntry(resource_id, &cache_entry))
+  if (!storage_->GetCacheEntry(resource_id, &cache_entry))
     return FILE_ERROR_NOT_FOUND;
 
   if (mounted_files_.count(resource_id))
     return FILE_ERROR_INVALID_OPERATION;
 
   // Ensure the file is readable to cros_disks. See crbug.com/236994.
   base::FilePath path = GetCacheFilePath(
       resource_id, cache_entry.md5(), CACHED_FILE_FROM_SERVER);
   file_util::SetPosixFilePermissions(
       path,
@@ skipping 27 matching lines @@
     return FILE_ERROR_INVALID_OPERATION;
 
   mounted_files_.erase(it);
   return FILE_ERROR_OK;
 }
 
 bool FileCache::ClearAll() {
   AssertOnSequencedWorkerPool();
 
   // Remove entries on the metadata.
-  scoped_ptr<FileCacheMetadata::Iterator> it = metadata_->GetIterator();
+  scoped_ptr<ResourceMetadataStorage::CacheEntryIterator> it =
+      storage_->GetCacheEntryIterator();
   for (; !it->IsAtEnd(); it->Advance())
-    metadata_->RemoveCacheEntry(it->GetKey());
+    storage_->RemoveCacheEntry(it->GetID());
 
   if (it->HasError())
     return false;
 
   // Remove files.
   base::FileEnumerator enumerator(cache_file_directory_,
                                   false,  // not recursive
                                   base::FileEnumerator::FILES);
   for (base::FilePath file = enumerator.Next(); !file.empty();
        file = enumerator.Next())
     file_util::Delete(file, false /* recursive */);
 
   return true;
 }
 
 bool FileCache::HasEnoughSpaceFor(int64 num_bytes,
                                   const base::FilePath& path) {
   int64 free_space = 0;
   if (free_disk_space_getter_)
     free_space = free_disk_space_getter_->AmountOfFreeDiskSpace();
   else
     free_space = base::SysInfo::AmountOfFreeDiskSpace(path);
 
   // Subtract this as if this portion does not exist.
   free_space -= kMinFreeSpace;
   return (free_space >= num_bytes);
 }
 
-void FileCache::ImportOldDB(const base::FilePath& old_db_path) {
+bool FileCache::ImportOldDB(const base::FilePath& old_db_path) {
   if (!file_util::PathExists(old_db_path))  // Old DB is not there, do nothing.
-    return;
+    return false;
 
   // Copy all entries stored in the old DB.
   FileCacheMetadata old_data(blocking_task_runner_);
   if (old_data.Initialize(old_db_path)) {
     scoped_ptr<FileCacheMetadata::Iterator> it = old_data.GetIterator();
     for (; !it->IsAtEnd(); it->Advance()) {
       FileCacheEntry entry;
-      if (metadata_->GetCacheEntry(it->GetKey(), &entry))
+      if (storage_->GetCacheEntry(it->GetKey(), &entry))
         continue;  // Do not overwrite.
 
-      metadata_->AddOrUpdateCacheEntry(it->GetKey(), it->GetValue());
+      storage_->PutCacheEntry(it->GetKey(), it->GetValue());
     }
   }

[kinaba, 2013/06/21 07:32:50]

When old_data.Initialize() failed, shouldn't we return false?

It is a rare case but I'm wondering whether we should scan cache file directory
in the case
file_util::PathExists(old_db_path) && !old_data.Initialize() &&
!storage_->opened_existing_db().
(And I think we should.)

[hashimoto, 2013/06/21 08:23:41]

Amazingly good catch.
Done as you suggested.

 
   // Delete old DB.
   file_util::Delete(old_db_path, true /* recursive */ );
+  return true;
 }
 
 }  // namespace internal
 }  // namespace drive