drive: Use base_name recovered from trashed DB when DB corruption happens

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 459 matching lines @@
       init_result = LevelDBStatusToDBInitStatus(status);
     }
   }
 
   UMA_HISTOGRAM_ENUMERATION("Drive.MetadataDBInitResult",
                             init_result,
                             DB_INIT_MAX_VALUE);
   return resource_map_;
 }
 
-void ResourceMetadataStorage::RecoverCacheEntriesFromTrashedResourceMap(
-    std::map<std::string, FileCacheEntry>* out_entries) {
+void ResourceMetadataStorage::RecoverCacheInfoFromTrashedResourceMap(
+    RecoveredCacheInfoMap* out_info) {
   const base::FilePath trashed_resource_map_path =
       directory_path_.Append(kTrashedResourceMapDBName);
 
   if (!base::PathExists(trashed_resource_map_path))
     return;
 
   leveldb::Options options;
   options.max_open_files = 0;  // Use minimum.
   options.create_if_missing = false;
 
@@ skipping 27 matching lines @@
     return;
   }
 
   // Collect cache entries.
   scoped_ptr<leveldb::Iterator> it(
       resource_map->NewIterator(leveldb::ReadOptions()));
   for (it->SeekToFirst(); it->Valid(); it->Next()) {
     if (IsCacheEntryKey(it->key())) {
       const std::string& id = GetIdFromCacheEntryKey(it->key());
       FileCacheEntry cache_entry;
-      if (cache_entry.ParseFromArray(it->value().data(), it->value().size()))
-        (*out_entries)[id] = cache_entry;
+      if (cache_entry.ParseFromArray(it->value().data(), it->value().size())) {
+        RecoveredCacheInfo* info = &(*out_info)[id];
+        info->is_dirty = cache_entry.is_dirty();
+        info->md5 = cache_entry.md5();
+
+        // Get title from ResourceEntry if available.
+        std::string serialized_entry;
+        ResourceEntry entry;
+        if (resource_map->Get(leveldb::ReadOptions(),
+                              leveldb::Slice(id),
+                              &serialized_entry).ok() &&
+            entry.ParseFromString(serialized_entry))
+          info->title = entry.title();
+      }
     }
   }
 }
 
 bool ResourceMetadataStorage::SetLargestChangestamp(
     int64 largest_changestamp) {
   base::ThreadRestrictions::AssertIOAllowed();
 
   ResourceMetadataHeader header;
   if (!GetHeader(&header)) {
@@ skipping 186 matching lines @@
 
 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() {}
+
 bool ResourceMetadataStorage::GetIdByResourceId(
     const std::string& resource_id,
     std::string* out_id) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(!resource_id.empty());
 
   const leveldb::Status status = resource_map_->Get(
       leveldb::ReadOptions(),
       leveldb::Slice(GetIdEntryKey(resource_id)),
       out_id);
@@ skipping 156 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