Add database recovery for FileSystemOriginDatabase

webkit/fileapi/file_system_origin_database.cc

 // Copyright (c) 2011 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 "webkit/fileapi/file_system_origin_database.h"
 
 #include "base/format_macros.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
@@ skipping 36 matching lines @@
 #if defined(OS_POSIX)
   path_ = path.value();
 #elif defined(OS_WIN)
   path_ = base::SysWideToUTF8(path.value());
 #endif
 }
 
 FileSystemOriginDatabase::~FileSystemOriginDatabase() {
 }
 
-bool FileSystemOriginDatabase::Init() {
+bool FileSystemOriginDatabase::Init(bool cleanup_if_corrupted) {
   if (db_.get())
     return true;
 
   leveldb::Options options;
   options.create_if_missing = true;
   leveldb::DB* db;
   leveldb::Status status = leveldb::DB::Open(options, path_, &db);
+  // TODO(tzik): Collect status metrics here.
   if (status.ok()) {
     db_.reset(db);
     return true;
   }
   HandleError(FROM_HERE, status);
+
+  if (cleanup_if_corrupted && CheckIfDatabaseCorrupted(status)) {
+    LOG(WARNING) << "FileSystem API origin database is corrupted."
+                 << " Attempting cleanup.";
+    if (leveldb::DestroyDB(path_, leveldb::Options()).ok()) {
+      LOG(WARNING) << "FileSystem API origin database cleanup completed."
+                   << " Reopening.";
+      return Init(false);
+    }
+    LOG(WARNING) << "Failed to cleanup FileSystem API origin database.";
+  }
+
   return false;
 }
 
+bool FileSystemOriginDatabase::CheckIfDatabaseCorrupted(
+    const leveldb::Status& status) const {
+  // TODO(tzik): Return status.code() == leveldb::Status::kCorruption, after
+  // leveldb roll.
+  return !status.ok();
+}
+
 void FileSystemOriginDatabase::HandleError(
     const tracked_objects::Location& from_here, leveldb::Status status) {
   db_.reset();
   LOG(ERROR) << "FileSystemOriginDatabase failed at: "
              << from_here.ToString() << " with error: " << status.ToString();
 }
 
 bool FileSystemOriginDatabase::HasOriginPath(const std::string& origin) {
-  if (!Init())
+  if (!Init(true))
     return false;
   if (origin.empty())
     return false;
   std::string path;
   leveldb::Status status =
       db_->Get(leveldb::ReadOptions(), OriginToOriginKey(origin), &path);
   if (status.ok())
     return true;
   if (status.IsNotFound())
     return false;
   HandleError(FROM_HERE, status);
   return false;
 }
 
 bool FileSystemOriginDatabase::GetPathForOrigin(
     const std::string& origin, FilePath* directory) {
-  if (!Init())
+  if (!Init(true))
     return false;
   DCHECK(directory);
   if (origin.empty())
     return false;
   std::string path_string;
   std::string origin_key = OriginToOriginKey(origin);
   leveldb::Status status =
       db_->Get(leveldb::ReadOptions(), origin_key, &path_string);
   if (status.IsNotFound()) {
     int last_path_number;
@@ skipping 16 matching lines @@
 #elif defined(OS_WIN)
     *directory = FilePath(base::SysUTF8ToWide(path_string));
 #endif
     return true;
   }
   HandleError(FROM_HERE, status);
   return false;
 }
 
 bool FileSystemOriginDatabase::RemovePathForOrigin(const std::string& origin) {
-  if (!Init())
+  if (!Init(true))
     return false;
   leveldb::Status status =
       db_->Delete(leveldb::WriteOptions(), OriginToOriginKey(origin));
   if (status.ok() || status.IsNotFound())
     return true;
   HandleError(FROM_HERE, status);
   return false;
 }
 
 bool FileSystemOriginDatabase::ListAllOrigins(
     std::vector<OriginRecord>* origins) {
-  if (!Init())
+  if (!Init(true))
     return false;
   DCHECK(origins);
   scoped_ptr<leveldb::Iterator> iter(db_->NewIterator(leveldb::ReadOptions()));
   std::string origin_key_prefix = OriginToOriginKey("");
   iter->Seek(origin_key_prefix);
   origins->clear();
   while(iter->Valid() &&
       StartsWithASCII(iter->key().ToString(), origin_key_prefix, true)) {
     std::string origin =
       iter->key().ToString().substr(origin_key_prefix.length());
 #if defined(OS_POSIX)
     FilePath path = FilePath(iter->value().ToString());
 #elif defined(OS_WIN)
     FilePath path = FilePath(base::SysUTF8ToWide(iter->value().ToString()));
 #endif
     origins->push_back(OriginRecord(origin, path));
     iter->Next();
   }
   return true;
 }
 
 void FileSystemOriginDatabase::DropDatabase() {
   db_.reset();
 }
 
 bool FileSystemOriginDatabase::GetLastPathNumber(int* number) {
-  if (!Init())
+  if (!Init(true))
     return false;
   DCHECK(number);
   std::string number_string;
   leveldb::Status status =
       db_->Get(leveldb::ReadOptions(), LastPathKey(), &number_string);
   if (status.ok())
     return base::StringToInt(number_string, number);
   if (!status.IsNotFound()) {
     HandleError(FROM_HERE, status);
     return false;
@@ skipping 11 matching lines @@
       db_->Put(leveldb::WriteOptions(), LastPathKey(), std::string("-1"));
   if (!status.ok()) {
     HandleError(FROM_HERE, status);
     return false;
   }
   *number = -1;
   return true;
 }
 
 }  // namespace fileapi