drive: Stop using FileCacheEntry related methods in 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/callback_helpers.h"
 #include "base/file_util.h"
@@ skipping 64 matching lines @@
   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<ResourceMetadataStorage::CacheEntryIterator> it =
-      storage_->GetCacheEntryIterator();
+  scoped_ptr<ResourceMetadataStorage::Iterator> it = storage_->GetIterator();
   for (; !it->IsAtEnd(); it->Advance()) {
-    const FileCacheEntry& entry = it->GetValue();
-    if (!entry.is_pinned() &&
-        !entry.is_dirty() &&
-        !mounted_files_.count(it->GetID()))
-      storage_->RemoveCacheEntry(it->GetID());
+    if (it->GetValue().file_specific_info().has_cache_state() &&
+        !it->GetValue().file_specific_info().cache_state().is_pinned() &&
+        !it->GetValue().file_specific_info().cache_state().is_dirty() &&
+        !mounted_files_.count(it->GetID())) {
+      ResourceEntry entry(it->GetValue());
+      entry.mutable_file_specific_info()->clear_cache_state();
+      storage_->PutEntry(entry);
+    }
   }
   if (it->HasError())
     return false;
 
   // Remove all files which have no corresponding cache entries.
   base::FileEnumerator enumerator(cache_file_directory_,
                                   false,  // not recursive
                                   base::FileEnumerator::FILES);
-  FileCacheEntry entry;
+  ResourceEntry entry;
   for (base::FilePath current = enumerator.Next(); !current.empty();
        current = enumerator.Next()) {
     std::string id = GetIdFromPath(current);
-    FileError error = storage_->GetCacheEntry(id, &entry);
-    if (error == FILE_ERROR_NOT_FOUND)
+    FileError error = storage_->GetEntry(id, &entry);
+    if (error == FILE_ERROR_NOT_FOUND ||
+        (error == FILE_ERROR_OK &&
+         !entry.file_specific_info().cache_state().is_present()))
       base::DeleteFile(current, false /* recursive */);
     else if (error != FILE_ERROR_OK)
       return false;
   }
 
   // Check the disk space again.
   return HasEnoughSpaceFor(num_bytes, cache_file_directory_);
 }
 
 FileError FileCache::GetFile(const std::string& id,
                              base::FilePath* cache_file_path) {
   AssertOnSequencedWorkerPool();
   DCHECK(cache_file_path);
 
-  FileCacheEntry cache_entry;
-  FileError error = storage_->GetCacheEntry(id, &cache_entry);
+  ResourceEntry entry;
+  FileError error = storage_->GetEntry(id, &entry);
   if (error != FILE_ERROR_OK)
     return error;
-  if (!cache_entry.is_present())
+  if (!entry.file_specific_info().cache_state().is_present())
     return FILE_ERROR_NOT_FOUND;
 
   *cache_file_path = GetCacheFilePath(id);
   return FILE_ERROR_OK;
 }
 
 FileError FileCache::Store(const std::string& id,
                            const std::string& md5,
                            const base::FilePath& source_path,
                            FileOperationType file_operation_type) {
   AssertOnSequencedWorkerPool();
 
+  ResourceEntry entry;
+  FileError error = storage_->GetEntry(id, &entry);
+  if (error != FILE_ERROR_OK)
+    return error;
+
   int64 file_size = 0;
   if (file_operation_type == FILE_OPERATION_COPY) {
     if (!base::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_LOCAL_SPACE;
 
@@ skipping 16 matching lines @@
 
   if (!success) {
     LOG(ERROR) << "Failed to store: "
                << "source_path = " << source_path.value() << ", "
                << "dest_path = " << dest_path.value() << ", "
                << "file_operation_type = " << file_operation_type;
     return FILE_ERROR_FAILED;
   }
 
   // Now that file operations have completed, update metadata.
-  FileCacheEntry cache_entry;
-  FileError error = storage_->GetCacheEntry(id, &cache_entry);
-  if (error != FILE_ERROR_OK && error != FILE_ERROR_NOT_FOUND)
-    return error;
-  cache_entry.set_md5(md5);
-  cache_entry.set_is_present(true);
+  FileCacheEntry* cache_state =
+      entry.mutable_file_specific_info()->mutable_cache_state();
+  cache_state->set_md5(md5);
+  cache_state->set_is_present(true);
   if (md5.empty())
-    cache_entry.set_is_dirty(true);
-  return storage_->PutCacheEntry(id, cache_entry);
+    cache_state->set_is_dirty(true);
+  return storage_->PutEntry(entry);
 }
 
 FileError FileCache::Pin(const std::string& id) {
   AssertOnSequencedWorkerPool();
 
-  FileCacheEntry cache_entry;
-  FileError error = storage_->GetCacheEntry(id, &cache_entry);
-  if (error != FILE_ERROR_OK && error != FILE_ERROR_NOT_FOUND)
+  ResourceEntry entry;
+  FileError error = storage_->GetEntry(id, &entry);
+  if (error != FILE_ERROR_OK)
     return error;
-  cache_entry.set_is_pinned(true);
-  return storage_->PutCacheEntry(id, cache_entry);
+  entry.mutable_file_specific_info()->mutable_cache_state()->set_is_pinned(
+      true);
+  return storage_->PutEntry(entry);
 }
 
 FileError FileCache::Unpin(const std::string& id) {
   AssertOnSequencedWorkerPool();
 
   // Unpinning a file means its entry must exist in cache.
-  FileCacheEntry cache_entry;
-  FileError error = storage_->GetCacheEntry(id, &cache_entry);
+  ResourceEntry entry;
+  FileError error = storage_->GetEntry(id, &entry);
   if (error != FILE_ERROR_OK)
     return error;
 
   // Now that file operations have completed, update metadata.
-  if (cache_entry.is_present()) {
-    cache_entry.set_is_pinned(false);
-    error = storage_->PutCacheEntry(id, cache_entry);
-    if (error != FILE_ERROR_OK)
-      return error;
+  if (entry.file_specific_info().cache_state().is_present()) {
+    entry.mutable_file_specific_info()->mutable_cache_state()->set_is_pinned(
+        false);
   } else {
     // Remove the existing entry if we are unpinning a non-present file.
-    error = storage_->RemoveCacheEntry(id);
-    if (error != FILE_ERROR_OK)
-      return error;
+    entry.mutable_file_specific_info()->clear_cache_state();
   }
+  error = storage_->PutEntry(entry);
+  if (error != FILE_ERROR_OK)
+    return error;
 
   // Now it's a chance to free up space if needed.
   FreeDiskSpaceIfNeededFor(0);
 
   return FILE_ERROR_OK;
 }
 
 FileError FileCache::MarkAsMounted(const std::string& id,
                                    base::FilePath* cache_file_path) {
   AssertOnSequencedWorkerPool();
   DCHECK(cache_file_path);
 
   // Get cache entry associated with the id and md5
-  FileCacheEntry cache_entry;
-  FileError error = storage_->GetCacheEntry(id, &cache_entry);
+  ResourceEntry entry;
+  FileError error = storage_->GetEntry(id, &entry);
   if (error != FILE_ERROR_OK)
     return error;
+  if (!entry.file_specific_info().cache_state().is_present())
+    return FILE_ERROR_NOT_FOUND;
 
   if (mounted_files_.count(id))
     return FILE_ERROR_INVALID_OPERATION;
 
   // Ensure the file is readable to cros_disks. See crbug.com/236994.
   base::FilePath path = GetCacheFilePath(id);
   if (!base::SetPosixFilePermissions(
           path,
           base::FILE_PERMISSION_READ_BY_USER |
           base::FILE_PERMISSION_WRITE_BY_USER |
           base::FILE_PERMISSION_READ_BY_GROUP |
           base::FILE_PERMISSION_READ_BY_OTHERS))
     return FILE_ERROR_FAILED;
 
   mounted_files_.insert(id);
 
   *cache_file_path = path;
   return FILE_ERROR_OK;
 }
 
 FileError FileCache::OpenForWrite(
     const std::string& id,
     scoped_ptr<base::ScopedClosureRunner>* file_closer) {
   AssertOnSequencedWorkerPool();
 
   // Marking a file dirty means its entry and actual file blob must exist in
   // cache.
-  FileCacheEntry cache_entry;
-  FileError error = storage_->GetCacheEntry(id, &cache_entry);
+  ResourceEntry entry;
+  FileError error = storage_->GetEntry(id, &entry);
   if (error != FILE_ERROR_OK)
     return error;
-  if (!cache_entry.is_present()) {
+  if (!entry.file_specific_info().cache_state().is_present()) {
     LOG(WARNING) << "Can't mark dirty a file that wasn't cached: " << id;
     return FILE_ERROR_NOT_FOUND;
   }
 
-  cache_entry.set_is_dirty(true);
-  cache_entry.clear_md5();
-  error = storage_->PutCacheEntry(id, cache_entry);
+  entry.mutable_file_specific_info()->mutable_cache_state()->set_is_dirty(true);
+  entry.mutable_file_specific_info()->mutable_cache_state()->clear_md5();
+  error = storage_->PutEntry(entry);
   if (error != FILE_ERROR_OK)
     return error;
 
   write_opened_files_[id]++;
   file_closer->reset(new base::ScopedClosureRunner(
       base::Bind(&google_apis::RunTaskOnThread,
                  blocking_task_runner_,
                  base::Bind(&FileCache::CloseForWrite,
                             weak_ptr_factory_.GetWeakPtr(),
                             id))));
   return FILE_ERROR_OK;
 }
 
 bool FileCache::IsOpenedForWrite(const std::string& id) {
   AssertOnSequencedWorkerPool();
   return write_opened_files_.count(id);
 }
 
 FileError FileCache::UpdateMd5(const std::string& id) {
   AssertOnSequencedWorkerPool();
 
   if (IsOpenedForWrite(id))
     return FILE_ERROR_IN_USE;
 
-  FileCacheEntry cache_entry;
-  FileError error = storage_->GetCacheEntry(id, &cache_entry);
+  ResourceEntry entry;
+  FileError error = storage_->GetEntry(id, &entry);
   if (error != FILE_ERROR_OK)
     return error;
-  if (!cache_entry.is_present())
+  if (!entry.file_specific_info().cache_state().is_present())
     return FILE_ERROR_NOT_FOUND;
 
   const std::string& md5 = util::GetMd5Digest(GetCacheFilePath(id));
   if (md5.empty())
     return FILE_ERROR_NOT_FOUND;
 
-  cache_entry.set_md5(md5);
-  return storage_->PutCacheEntry(id, cache_entry);
+  entry.mutable_file_specific_info()->mutable_cache_state()->set_md5(md5);
+  return storage_->PutEntry(entry);
 }
 
 FileError FileCache::ClearDirty(const std::string& id) {
   AssertOnSequencedWorkerPool();
 
   if (IsOpenedForWrite(id))
     return FILE_ERROR_IN_USE;
 
   // Clearing a dirty file means its entry and actual file blob must exist in
   // cache.
-  FileCacheEntry cache_entry;
-  FileError error = storage_->GetCacheEntry(id, &cache_entry);
+  ResourceEntry entry;
+  FileError error = storage_->GetEntry(id, &entry);
   if (error != FILE_ERROR_OK)
     return error;
-  if (!cache_entry.is_present()) {
+  if (!entry.file_specific_info().cache_state().is_present()) {
     LOG(WARNING) << "Can't clear dirty state of a file that wasn't cached: "
                  << id;
     return FILE_ERROR_NOT_FOUND;
   }
 
   // If a file is not dirty (it should have been marked dirty via OpenForWrite),
   // clearing its dirty state is an invalid operation.
-  if (!cache_entry.is_dirty()) {
+  if (!entry.file_specific_info().cache_state().is_dirty()) {
     LOG(WARNING) << "Can't clear dirty state of a non-dirty file: " << id;
     return FILE_ERROR_INVALID_OPERATION;
   }
 
-  cache_entry.set_is_dirty(false);
-  return storage_->PutCacheEntry(id, cache_entry);
+  entry.mutable_file_specific_info()->mutable_cache_state()->set_is_dirty(
+      false);
+  return storage_->PutEntry(entry);
 }
 
 FileError FileCache::Remove(const std::string& id) {
   AssertOnSequencedWorkerPool();
 
-  FileCacheEntry cache_entry;
+  ResourceEntry entry;
 
   // If entry doesn't exist, nothing to do.
-  FileError error = storage_->GetCacheEntry(id, &cache_entry);
+  FileError error = storage_->GetEntry(id, &entry);
   if (error == FILE_ERROR_NOT_FOUND)
     return FILE_ERROR_OK;
   if (error != FILE_ERROR_OK)
     return error;
+  if (!entry.file_specific_info().has_cache_state())
+    return FILE_ERROR_OK;
 
   // Cannot delete a mounted file.
   if (mounted_files_.count(id))
     return FILE_ERROR_IN_USE;
 
   // Delete the file.
   base::FilePath path = GetCacheFilePath(id);
   if (!base::DeleteFile(path, false /* recursive */))
     return FILE_ERROR_FAILED;
 
   // Now that all file operations have completed, remove from metadata.
-  return storage_->RemoveCacheEntry(id);
+  entry.mutable_file_specific_info()->clear_cache_state();
+  return storage_->PutEntry(entry);
 }
 
 bool FileCache::ClearAll() {
   AssertOnSequencedWorkerPool();
 
-  // Remove entries on the metadata.
-  scoped_ptr<ResourceMetadataStorage::CacheEntryIterator> it =
-      storage_->GetCacheEntryIterator();
-  for (; !it->IsAtEnd(); it->Advance()) {
-    if (storage_->RemoveCacheEntry(it->GetID()) != FILE_ERROR_OK)
-      return false;
-  }
-
-  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())
     base::DeleteFile(file, false /* recursive */);
 
   return true;
 }
 
 bool FileCache::Initialize() {
   AssertOnSequencedWorkerPool();
 
   // Older versions do not clear MD5 when marking entries dirty.
   // Clear MD5 of all dirty entries to deal with old data.
-  scoped_ptr<ResourceMetadataStorage::CacheEntryIterator> it =
-      storage_->GetCacheEntryIterator();
+  scoped_ptr<ResourceMetadataStorage::Iterator> it = storage_->GetIterator();
   for (; !it->IsAtEnd(); it->Advance()) {
-    if (it->GetValue().is_dirty()) {
-      FileCacheEntry new_entry(it->GetValue());
-      new_entry.clear_md5();
-      if (storage_->PutCacheEntry(it->GetID(), new_entry) != FILE_ERROR_OK)
+    if (it->GetValue().file_specific_info().cache_state().is_dirty()) {
+      ResourceEntry new_entry(it->GetValue());
+      new_entry.mutable_file_specific_info()->mutable_cache_state()->
+          clear_md5();
+      if (storage_->PutEntry(new_entry) != FILE_ERROR_OK)
         return false;
     }
   }
   if (it->HasError())
     return false;
 
   if (!RenameCacheFilesToNewFormat())
     return false;
   return true;
 }
@@ skipping 19 matching lines @@
     const ResourceMetadataStorage::RecoveredCacheInfoMap&
         recovered_cache_info) {
   int file_number = 1;
 
   base::FileEnumerator enumerator(cache_file_directory_,
                                   false,  // not recursive
                                   base::FileEnumerator::FILES);
   for (base::FilePath current = enumerator.Next(); !current.empty();
        current = enumerator.Next()) {
     const std::string& id = GetIdFromPath(current);
-    FileCacheEntry entry;
-    FileError error = storage_->GetCacheEntry(id, &entry);
-    if (error == FILE_ERROR_OK) {
+    ResourceEntry entry;
+    FileError error = storage_->GetEntry(id, &entry);
+    if (error != FILE_ERROR_OK && error != FILE_ERROR_NOT_FOUND)
+      return false;
+    if (error == FILE_ERROR_OK &&
+        entry.file_specific_info().cache_state().is_present()) {
       // This file is managed by FileCache, no need to recover it.
       continue;
     }
-    if (error != FILE_ERROR_NOT_FOUND)
-      return false;
 
     // If a cache entry which is non-dirty and has matching MD5 is found in
     // |recovered_cache_entries|, it means the current file is already uploaded
     // to the server. Just delete it instead of recovering it.
     ResourceMetadataStorage::RecoveredCacheInfoMap::const_iterator it =
         recovered_cache_info.find(id);
     if (it != recovered_cache_info.end()) {
       // Due to the DB corruption, cache info might be recovered from old
       // revision. Perform MD5 check even when is_dirty is false just in case.
       if (!it->second.is_dirty &&
@@ skipping 62 matching lines @@
                        file_number - 1);
   return true;
 }
 
 FileError FileCache::MarkAsUnmounted(const base::FilePath& file_path) {
   AssertOnSequencedWorkerPool();
   DCHECK(IsUnderFileCacheDirectory(file_path));
 
   std::string id = GetIdFromPath(file_path);
 
-  // Get cache entry associated with the id and md5
-  FileCacheEntry cache_entry;
-  FileError error = storage_->GetCacheEntry(id, &cache_entry);
+  // Get the entry associated with the id.
+  ResourceEntry entry;
+  FileError error = storage_->GetEntry(id, &entry);
   if (error != FILE_ERROR_OK)
     return error;
 
   std::set<std::string>::iterator it = mounted_files_.find(id);
   if (it == mounted_files_.end())
     return FILE_ERROR_INVALID_OPERATION;
 
   mounted_files_.erase(it);
   return FILE_ERROR_OK;
 }
@@ skipping 40 matching lines @@
     return;
 
   DCHECK_LT(0, it->second);
   --it->second;
   if (it->second == 0)
     write_opened_files_.erase(it);
 }
 
 }  // namespace internal
 }  // namespace drive