drive: Stop using FileCacheEntry related methods in FileCache

chrome/browser/chromeos/drive/resource_metadata_storage.cc

 // Copyright 2013 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/resource_metadata_storage.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/location.h"
 #include "base/logging.h"
@@ skipping 222 matching lines @@
       break;
     }
   }
 }
 
 bool ResourceMetadataStorage::Iterator::HasError() const {
   base::ThreadRestrictions::AssertIOAllowed();
   return !it_->status().ok();
 }
 
-ResourceMetadataStorage::CacheEntryIterator::CacheEntryIterator(
-    scoped_ptr<leveldb::Iterator> it) : it_(it.Pass()) {
-  base::ThreadRestrictions::AssertIOAllowed();
-  DCHECK(it_);
-
-  it_->SeekToFirst();
-  AdvanceInternal();
-}
-
-ResourceMetadataStorage::CacheEntryIterator::~CacheEntryIterator() {
-  base::ThreadRestrictions::AssertIOAllowed();
-}
-
-bool ResourceMetadataStorage::CacheEntryIterator::IsAtEnd() const {
-  base::ThreadRestrictions::AssertIOAllowed();
-  return !it_->Valid();
-}
-
-const std::string& ResourceMetadataStorage::CacheEntryIterator::GetID() const {
-  base::ThreadRestrictions::AssertIOAllowed();
-  DCHECK(!IsAtEnd());
-  return id_;
-}
-
-const FileCacheEntry&
-ResourceMetadataStorage::CacheEntryIterator::GetValue() const {
-  base::ThreadRestrictions::AssertIOAllowed();
-  DCHECK(!IsAtEnd());
-  return entry_;
-}
-
-void ResourceMetadataStorage::CacheEntryIterator::Advance() {
-  base::ThreadRestrictions::AssertIOAllowed();
-  DCHECK(!IsAtEnd());
-
-  it_->Next();
-  AdvanceInternal();
-}
-
-bool ResourceMetadataStorage::CacheEntryIterator::HasError() const {
-  base::ThreadRestrictions::AssertIOAllowed();
-  return !it_->status().ok();
-}
-
-void ResourceMetadataStorage::CacheEntryIterator::AdvanceInternal() {
-  for (; it_->Valid(); it_->Next()) {
-    // Skip unparsable broken entries.
-    // TODO(hashimoto): Broken entries should be cleaned up at some point.
-    if (IsCacheEntryKey(it_->key()) &&
-        entry_.ParseFromArray(it_->value().data(), it_->value().size())) {
-      id_ = GetIdFromCacheEntryKey(it_->key());
-      break;
-    }
-  }
-}
-
 // static
 bool ResourceMetadataStorage::UpgradeOldDB(
     const base::FilePath& directory_path,
     const ResourceIdCanonicalizer& id_canonicalizer) {
   base::ThreadRestrictions::AssertIOAllowed();
   COMPILE_ASSERT(
       kDBVersion == 12,
       db_version_and_this_function_should_be_updated_at_the_same_time);
 
   const base::FilePath resource_map_path =
@@ skipping 349 matching lines @@
 
   // Put the cache entry.
   // TODO(hashimoto): Change DB layout and remove this.
   if (entry.file_specific_info().has_cache_state()) {
     if (!entry.file_specific_info().cache_state().SerializeToString(
             &serialized_entry)) {
       DLOG(ERROR) << "Failed to serialize the cache entry.";
       return FILE_ERROR_FAILED;
     }
     batch.Put(GetCacheEntryKey(id), serialized_entry);
+  } else {
+    batch.Delete(GetCacheEntryKey(id));

[kinaba, 2014/05/19 08:22:54]

Wouldn't it be problematic when old_entry had cache info but the new entry
(which for instance came from ResourceMetadata::RefreshEntry) did not?

[hashimoto, 2014/05/20 02:46:33]

You're right.
I should have addressed it first, but it slipped off of my mind for some reason.
Thanks, modified RefreshEntry.

   }
 
   // Put the entry itself.
   {
     // Clear cache state as it's stored separately.
     // TODO(hashimoto): Change DB layout and remove this.
     ResourceEntry entry_copied(entry);
     entry_copied.mutable_file_specific_info()->clear_cache_state();
     if (!entry_copied.SerializeToString(&serialized_entry)) {
       DLOG(ERROR) << "Failed to serialize the entry: " << id;
@@ skipping 23 matching lines @@
                                                     leveldb::Slice(id),
                                                     &serialized_entry);
   if (!status.ok())
     return LevelDBStatusToFileError(status);
   if (!out_entry->ParseFromString(serialized_entry))
     return FILE_ERROR_FAILED;
 
   if (cache_error == FILE_ERROR_OK) {
     *out_entry->mutable_file_specific_info()->mutable_cache_state() =
         cache_entry;
+  } else {
+    out_entry->mutable_file_specific_info()->clear_cache_state();
   }
   return FILE_ERROR_OK;
 }
 
 FileError ResourceMetadataStorage::RemoveEntry(const std::string& id) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(!id.empty());
 
   ResourceEntry entry;
   FileError error = GetEntry(id, &entry);
@@ skipping 57 matching lines @@
       resource_map_->NewIterator(leveldb::ReadOptions()));
   for (it->Seek(parent_id);
        it->Valid() && it->key().starts_with(leveldb::Slice(parent_id));
        it->Next()) {
     if (IsChildEntryKey(it->key()))
       children->push_back(it->value().ToString());
   }
   return LevelDBStatusToFileError(it->status());
 }
 
-FileError ResourceMetadataStorage::PutCacheEntry(const std::string& id,
-                                                 const FileCacheEntry& entry) {
-  base::ThreadRestrictions::AssertIOAllowed();
-  DCHECK(!id.empty());
-
-  std::string serialized_entry;
-  if (!entry.SerializeToString(&serialized_entry)) {
-    DLOG(ERROR) << "Failed to serialize the entry.";
-    return FILE_ERROR_FAILED;
-  }
-
-  const leveldb::Status status = resource_map_->Put(
-      leveldb::WriteOptions(),
-      leveldb::Slice(GetCacheEntryKey(id)),
-      leveldb::Slice(serialized_entry));
-  return LevelDBStatusToFileError(status);
-}
-
 FileError ResourceMetadataStorage::GetCacheEntry(const std::string& id,
                                                  FileCacheEntry* out_entry) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(!id.empty());
 
   std::string serialized_entry;
   const leveldb::Status status = resource_map_->Get(
       leveldb::ReadOptions(),
       leveldb::Slice(GetCacheEntryKey(id)),
       &serialized_entry);
   if (!status.ok())
     return LevelDBStatusToFileError(status);
   return out_entry->ParseFromString(serialized_entry) ?
       FILE_ERROR_OK : FILE_ERROR_FAILED;
 }
 
-FileError ResourceMetadataStorage::RemoveCacheEntry(const std::string& id) {
-  base::ThreadRestrictions::AssertIOAllowed();
-  DCHECK(!id.empty());
-
-  const leveldb::Status status = resource_map_->Delete(
-      leveldb::WriteOptions(),
-      leveldb::Slice(GetCacheEntryKey(id)));
-  return LevelDBStatusToFileError(status);
-}
-
-scoped_ptr<ResourceMetadataStorage::CacheEntryIterator>
-ResourceMetadataStorage::GetCacheEntryIterator() {
-  base::ThreadRestrictions::AssertIOAllowed();
-
-  scoped_ptr<leveldb::Iterator> it(
-      resource_map_->NewIterator(leveldb::ReadOptions()));
-  return make_scoped_ptr(new CacheEntryIterator(it.Pass()));
-}
-
 ResourceMetadataStorage::RecoveredCacheInfo::RecoveredCacheInfo()
     : is_dirty(false) {}
 
 ResourceMetadataStorage::RecoveredCacheInfo::~RecoveredCacheInfo() {}
 
 FileError ResourceMetadataStorage::GetIdByResourceId(
     const std::string& resource_id,
     std::string* out_id) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(!resource_id.empty());
@@ skipping 164 matching lines @@
   if (!it->status().ok() || num_child_entries != num_entries_with_parent) {
     DLOG(ERROR) << "Error during checking resource map. status = "
                 << it->status().ToString();
     return false;
   }
   return true;
 }
 
 }  // namespace internal
 }  // namespace drive