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

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"
@@ skipping 375 matching lines @@
       FROM_HERE,
       base::Bind(&FileCache::DestroyOnBlockingPool, base::Unretained(this)));
 }
 
 void FileCache::DestroyOnBlockingPool() {
   AssertOnSequencedWorkerPool();
   delete this;
 }
 
 bool FileCache::RecoverFilesFromCacheDirectory(
-    const base::FilePath& dest_directory) {
+    const base::FilePath& dest_directory,
+    const std::map<std::string, FileCacheEntry>& recovered_cache_entries) {
   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;
     if (storage_->GetCacheEntry(id, &entry)) {
       // This file is managed by FileCache, no need to recover it.
       continue;
     }
 
+    // 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.
+    std::map<std::string, FileCacheEntry>::const_iterator it =
+        recovered_cache_entries.find(id);
+    if (it != recovered_cache_entries.end()) {
+      const FileCacheEntry& recovered_entry = it->second;
+      // Due to the DB corruption, |recovered_entry| might be recovered from old
+      // revision. Perform MD5 check even when is_dirty() is false just in case.
+      if (!recovered_entry.is_dirty() &&
+          recovered_entry.md5() == util::GetMd5Digest(current)) {
+        base::DeleteFile(current, false /* recursive */);
+        continue;
+      }
+    }
+
     // Read file contents to sniff mime type.
     std::vector<char> content(net::kMaxBytesToSniff);
     const int read_result =
         file_util::ReadFile(current, &content[0], content.size());
     if (read_result < 0) {
       LOG(WARNING) << "Cannot read: " << current.value();
       return false;
     }
     if (read_result == 0)  // Skip empty files.
       continue;
@@ skipping 140 matching lines @@
     const std::string& id = GetIdFromPath(new_path);
     new_path = GetCacheFilePath(util::CanonicalizeResourceId(id));
     if (new_path != current && !base::Move(current, new_path))
       return false;
   }
   return true;
 }
 
 }  // namespace internal
 }  // namespace drive