drive: Recover cache entries from trashed DB to filter out non-dirty cache files

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 23 matching lines @@
 };
 
 // The name of the DB which stores the metadata.
 const base::FilePath::CharType kResourceMapDBName[] =
     FILE_PATH_LITERAL("resource_metadata_resource_map.db");
 
 // The name of the DB which couldn't be opened, but is preserved just in case.
 const base::FilePath::CharType kPreservedResourceMapDBName[] =
     FILE_PATH_LITERAL("resource_metadata_preserved_resource_map.db");
 
+// The name of the DB which couldn't be opened, and was replaced with a new one.
+const base::FilePath::CharType kTrashedResourceMapDBName[] =
+    FILE_PATH_LITERAL("resource_metadata_trashed_resource_map.db");
+
 // Meant to be a character which never happen to be in real IDs.
 const char kDBKeyDelimeter = '\0';
 
 // String used as a suffix of a key for a cache entry.
 const char kCacheEntryKeySuffix[] = "CACHE";
 
 // String used as a prefix of a key for a resource-ID-to-local-ID entry.
 const char kIdEntryKeyPrefix[] = "ID";
 
 // Returns a string to be used as the key for the header.
@@ skipping 76 matching lines @@
     return DB_INIT_IO_ERROR;
   return DB_INIT_FAILED;
 }
 
 ResourceMetadataHeader GetDefaultHeaderEntry() {
   ResourceMetadataHeader header;
   header.set_version(ResourceMetadataStorage::kDBVersion);
   return header;
 }
 
+bool MoveIfPossible(const base::FilePath& from, const base::FilePath& to) {
+  return !base::PathExists(from) || base::Move(from, to);
+}
+
 }  // namespace
 
 ResourceMetadataStorage::Iterator::Iterator(scoped_ptr<leveldb::Iterator> it)
   : it_(it.Pass()) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(it_);
 
   // Skip the header entry.
   // Note: The header entry comes before all other entries because its key
   // starts with kDBKeyDelimeter. (i.e. '\0')
@@ skipping 217 matching lines @@
 
 bool ResourceMetadataStorage::Initialize() {
   base::ThreadRestrictions::AssertIOAllowed();
 
   resource_map_.reset();
 
   const base::FilePath resource_map_path =
       directory_path_.Append(kResourceMapDBName);
   const base::FilePath preserved_resource_map_path =
       directory_path_.Append(kPreservedResourceMapDBName);
+  const base::FilePath trashed_resource_map_path =
+      directory_path_.Append(kTrashedResourceMapDBName);
+
+  // Discard unneeded DBs.
+  if (!base::DeleteFile(preserved_resource_map_path, true /* recursive */) ||
+      !base::DeleteFile(trashed_resource_map_path, true /* recursive */)) {
+    LOG(ERROR) << "Failed to remove unneeded DBs.";
+    return false;
+  }
 
   // Try to open the existing DB.
   leveldb::DB* db = NULL;
   leveldb::Options options;
   options.max_open_files = 0;  // Use minimum.
   options.create_if_missing = false;
 
   DBInitStatus open_existing_result = DB_INIT_NOT_FOUND;
   leveldb::Status status;
   if (base::PathExists(resource_map_path)) {
@@ skipping 31 matching lines @@
                             open_existing_result,
                             DB_INIT_MAX_VALUE);
 
   DBInitStatus init_result = DB_INIT_SUCCESS;
 
   // Failed to open the existing DB, create new DB.
   if (!resource_map_) {
     // Move the existing DB to the preservation path. The moved old DB is
     // deleted once the new DB creation succeeds, or is restored later in
     // UpgradeOldDB() when the creation fails.
-    if (base::PathExists(resource_map_path) &&
-        base::DeleteFile(preserved_resource_map_path, true /* recursive */))
-      base::Move(resource_map_path, preserved_resource_map_path);
+    MoveIfPossible(resource_map_path, preserved_resource_map_path);
 
     // Create DB.
     options.max_open_files = 0;  // Use minimum.
     options.create_if_missing = true;
     options.error_if_exists = true;
 
     status = leveldb::DB::Open(options, resource_map_path.AsUTF8Unsafe(), &db);
     if (status.ok()) {
       resource_map_.reset(db);
 
       if (!PutHeader(GetDefaultHeaderEntry()) ||  // Set up header.
-          !base::DeleteFile(preserved_resource_map_path,
-                            true /* recursive */)) {  // Remove the old DB.
+          !MoveIfPossible(preserved_resource_map_path,  // Trash the old DB.
+                          trashed_resource_map_path)) {
         init_result = DB_INIT_FAILED;
         resource_map_.reset();
       }
     } else {
       LOG(ERROR) << "Failed to create resource map DB: " << status.ToString();
       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) {
+  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;
+
+  // Trashed DB may be broken, repair it first.
+  leveldb::Status status;
+  status = leveldb::RepairDB(trashed_resource_map_path.AsUTF8Unsafe(), options);
+  if (!status.ok()) {
+    LOG(ERROR) << "Failed to repair trashed DB: " << status.ToString();
+    return;
+  }
+
+  // Open it.
+  leveldb::DB* db = NULL;
+  status = leveldb::DB::Open(options, trashed_resource_map_path.AsUTF8Unsafe(),
+                             &db);
+  if (!status.ok()) {
+    LOG(ERROR) << "Failed to open trashed DB: " << status.ToString();
+    return;
+  }
+  scoped_ptr<leveldb::DB> resource_map(db);
+
+  // Check DB version.
+  std::string serialized_header;
+  ResourceMetadataHeader header;
+  if (!resource_map->Get(leveldb::ReadOptions(),
+                         leveldb::Slice(GetHeaderDBKey()),
+                         &serialized_header).ok() ||
+      !header.ParseFromString(serialized_header) ||
+      header.version() != kDBVersion) {
+    LOG(ERROR) << "Incompatible DB version: " << header.version();
+    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;
+    }
+  }
+}
+
 bool ResourceMetadataStorage::SetLargestChangestamp(
     int64 largest_changestamp) {
   base::ThreadRestrictions::AssertIOAllowed();
 
   ResourceMetadataHeader header;
   if (!GetHeader(&header)) {
     DLOG(ERROR) << "Failed to get the header.";
     return false;
   }
   header.set_largest_changestamp(largest_changestamp);
@@ skipping 358 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