Add database recovery for FileSystemOriginDatabase

webkit/fileapi/file_system_origin_database_unittest.cc

Index: webkit/fileapi/file_system_origin_database_unittest.cc
diff --git a/webkit/fileapi/file_system_origin_database_unittest.cc b/webkit/fileapi/file_system_origin_database_unittest.cc
index c34e636a6a3160dee82561be6c43cf3c583d1652..64ed948312d535940fc74478e0cd0aa32fd1a0f2 100644
--- a/webkit/fileapi/file_system_origin_database_unittest.cc
+++ b/webkit/fileapi/file_system_origin_database_unittest.cc
@@ -6,19 +6,102 @@
 
 #include <string>
 
+#include "base/file_path.h"
 #include "base/file_util.h"
+#include "base/platform_file.h"
 #include "base/scoped_temp_dir.h"
+#include "base/stl_util.h"
+#include "third_party/leveldatabase/src/db/filename.h"
+#include "third_party/leveldatabase/src/include/leveldb/db.h"
 #include "webkit/fileapi/file_system_origin_database.h"
 
 namespace fileapi {
 
+namespace {
+const FilePath::CharType kFileSystemDirName[] =
+    FILE_PATH_LITERAL("File System");
+const FilePath::CharType kOriginDatabaseName[] = FILE_PATH_LITERAL("Origins");
+
+std::string FilePathToUTF8(const FilePath& path) {
+#if defined(OS_POSIX)
+  return path.value();
+#elif defined(OS_WIN)
+  return base::SysWideToUTF8(path.value());
+#endif

[kinuko, 2012/03/23 04:01:33]

Ditto for ifdefs

[tzik, 2012/03/23 07:09:00]

ditto

+}
+
+FilePath UTF8ToFilePath(const std::string& path_string) {
+  return FilePath::FromUTF8Unsafe(path_string);
+}
+
+void CorruptDatabase(const FilePath& db_path,
+                     leveldb::FileType type,
+                     ptrdiff_t offset,
+                     size_t size) {
+  file_util::FileEnumerator file_enum(
+      db_path, false /* recursive */,
+      static_cast<file_util::FileEnumerator::FileType>(
+          file_util::FileEnumerator::DIRECTORIES |
+          file_util::FileEnumerator::FILES));
+  FilePath file_path;
+  FilePath picked_file_path;
+  uint64 picked_file_number = kuint64max;
+
+  while (!(file_path = file_enum.Next()).empty()) {
+    uint64 number = -1;
+    leveldb::FileType file_type;
+    EXPECT_TRUE(leveldb::ParseFileName(FilePathToUTF8(file_path.BaseName()),
+                                       &number, &file_type));
+    if (file_type == type &&
+        (picked_file_number == kuint64max || picked_file_number < number)) {
+      picked_file_path = file_path;
+      picked_file_number = number;
+    }
+  }
+
+  EXPECT_FALSE(picked_file_path.empty());
+  EXPECT_NE(kuint64max, picked_file_number);
+
+  bool created = true;
+  base::PlatformFileError error = base::PLATFORM_FILE_ERROR_FAILED;
+  base::PlatformFile file =
+      CreatePlatformFile(picked_file_path,
+                         base::PLATFORM_FILE_OPEN |
+                         base::PLATFORM_FILE_READ |
+                         base::PLATFORM_FILE_WRITE,
+                         &created, &error);
+  EXPECT_EQ(base::PLATFORM_FILE_OK, error);
+  EXPECT_FALSE(created);
+
+  std::vector<char> buf(size);
+
+  int read_size = base::ReadPlatformFile(file, offset,
+                                         vector_as_array(buf), buf.size());
+  EXPECT_LT(0, read_size);
+  EXPECT_GE(buf.size(), static_cast<size_t>(read_size));
+  buf.resize(read_size);
+
+  std::transform(buf.begin(), buf.end(), buf.begin(),
+                 std::logical_not<char>());
+
+  int wrote_size = base::WritePlatformFile(file, offset,
+                                           vector_as_array(buf), buf.size());
+  EXPECT_LE(0, wrote_size);
+  EXPECT_EQ(buf.size(), static_cast<size_t>(wrote_size));
+
+  base::ClosePlatformFile(file);
+}
+
+}
+
 TEST(FileSystemOriginDatabaseTest, BasicTest) {
   ScopedTempDir dir;
   ASSERT_TRUE(dir.CreateUniqueTempDir());
-  const FilePath kDBFile = dir.path().AppendASCII("fsod.db");
-  EXPECT_FALSE(file_util::PathExists(kDBFile));
+  const FilePath kFSDir = dir.path().Append(kFileSystemDirName);
+  EXPECT_FALSE(file_util::PathExists(kFSDir));
+  EXPECT_TRUE(file_util::CreateDirectory(kFSDir));
 
-  FileSystemOriginDatabase database(kDBFile);
+  FileSystemOriginDatabase database(kFSDir);
   std::string origin("origin");
 
   EXPECT_FALSE(database.HasOriginPath(origin));
@@ -38,16 +121,17 @@ TEST(FileSystemOriginDatabaseTest, BasicTest) {
   EXPECT_FALSE(path1.empty());
   EXPECT_EQ(path0, path1);
 
-  EXPECT_TRUE(file_util::PathExists(kDBFile));
+  EXPECT_TRUE(file_util::PathExists(kFSDir.Append(kOriginDatabaseName)));
 }
 
 TEST(FileSystemOriginDatabaseTest, TwoPathTest) {
   ScopedTempDir dir;
   ASSERT_TRUE(dir.CreateUniqueTempDir());
-  const FilePath kDBFile = dir.path().AppendASCII("fsod.db");
-  EXPECT_FALSE(file_util::PathExists(kDBFile));
+  const FilePath kFSDir = dir.path().Append(kFileSystemDirName);
+  EXPECT_FALSE(file_util::PathExists(kFSDir));
+  EXPECT_TRUE(file_util::CreateDirectory(kFSDir));
 
-  FileSystemOriginDatabase database(kDBFile);
+  FileSystemOriginDatabase database(kFSDir);
   std::string origin0("origin0");
   std::string origin1("origin1");
 
@@ -65,16 +149,17 @@ TEST(FileSystemOriginDatabaseTest, TwoPathTest) {
   EXPECT_FALSE(path1.empty());
   EXPECT_NE(path0, path1);
 
-  EXPECT_TRUE(file_util::PathExists(kDBFile));
+  EXPECT_TRUE(file_util::PathExists(kFSDir.Append(kOriginDatabaseName)));
 }
 
 TEST(FileSystemOriginDatabaseTest, DropDatabaseTest) {
   ScopedTempDir dir;
   ASSERT_TRUE(dir.CreateUniqueTempDir());
-  const FilePath kDBFile = dir.path().AppendASCII("fsod.db");
-  EXPECT_FALSE(file_util::PathExists(kDBFile));
+  const FilePath kFSDir = dir.path().Append(kFileSystemDirName);
+  EXPECT_FALSE(file_util::PathExists(kFSDir));
+  EXPECT_TRUE(file_util::CreateDirectory(kFSDir));
 
-  FileSystemOriginDatabase database(kDBFile);
+  FileSystemOriginDatabase database(kFSDir);
   std::string origin("origin");
 
   EXPECT_FALSE(database.HasOriginPath(origin));
@@ -84,7 +169,7 @@ TEST(FileSystemOriginDatabaseTest, DropDatabaseTest) {
   EXPECT_TRUE(database.HasOriginPath(origin));
   EXPECT_FALSE(path0.empty());
 
-  EXPECT_TRUE(file_util::PathExists(kDBFile));
+  EXPECT_TRUE(file_util::PathExists(kFSDir.Append(kOriginDatabaseName)));
 
   database.DropDatabase();
 
@@ -98,10 +183,11 @@ TEST(FileSystemOriginDatabaseTest, DropDatabaseTest) {
 TEST(FileSystemOriginDatabaseTest, DeleteOriginTest) {
   ScopedTempDir dir;
   ASSERT_TRUE(dir.CreateUniqueTempDir());
-  const FilePath kDBFile = dir.path().AppendASCII("fsod.db");
-  EXPECT_FALSE(file_util::PathExists(kDBFile));
+  const FilePath kFSDir = dir.path().Append(kFileSystemDirName);
+  EXPECT_FALSE(file_util::PathExists(kFSDir));
+  EXPECT_TRUE(file_util::CreateDirectory(kFSDir));
 
-  FileSystemOriginDatabase database(kDBFile);
+  FileSystemOriginDatabase database(kFSDir);
   std::string origin("origin");
 
   EXPECT_FALSE(database.HasOriginPath(origin));
@@ -124,12 +210,13 @@ TEST(FileSystemOriginDatabaseTest, DeleteOriginTest) {
 TEST(FileSystemOriginDatabaseTest, ListOriginsTest) {
   ScopedTempDir dir;
   ASSERT_TRUE(dir.CreateUniqueTempDir());
-  const FilePath kDBFile = dir.path().AppendASCII("fsod.db");
-  EXPECT_FALSE(file_util::PathExists(kDBFile));
+  const FilePath kFSDir = dir.path().Append(kFileSystemDirName);
+  EXPECT_FALSE(file_util::PathExists(kFSDir));
+  EXPECT_TRUE(file_util::CreateDirectory(kFSDir));
 
   std::vector<FileSystemOriginDatabase::OriginRecord> origins;
 
-  FileSystemOriginDatabase database(kDBFile);
+  FileSystemOriginDatabase database(kFSDir);
   EXPECT_TRUE(database.ListAllOrigins(&origins));
   EXPECT_TRUE(origins.empty());
   origins.clear();
@@ -163,4 +250,66 @@ TEST(FileSystemOriginDatabaseTest, ListOriginsTest) {
   }
 }
 
+TEST(FileSystemOriginDatabaseTest, DatabaseRecoveryTest) {
+  ScopedTempDir dir;
+  ASSERT_TRUE(dir.CreateUniqueTempDir());
+  const FilePath kFSDir = dir.path().Append(kFileSystemDirName);
+  const FilePath kDBDir = kFSDir.Append(kOriginDatabaseName);
+  EXPECT_FALSE(file_util::PathExists(kFSDir));
+  EXPECT_TRUE(file_util::CreateDirectory(kFSDir));
+
+  const std::string kOrigins[] = {
+    "foo.example.com",
+    "bar.example.com",
+    "baz.example.com",
+    "hoge.example.com",
+    "fuga.example.com",
+  };
+
+  scoped_ptr<FileSystemOriginDatabase> database(
+      new FileSystemOriginDatabase(kFSDir));
+  for (size_t i = 0; i < arraysize(kOrigins); ++i) {
+    FilePath path;
+    EXPECT_FALSE(database->HasOriginPath(kOrigins[i]));
+    EXPECT_TRUE(database->GetPathForOrigin(kOrigins[i], &path));
+    EXPECT_FALSE(path.empty());
+    EXPECT_TRUE(database->GetPathForOrigin(kOrigins[i], &path));
+
+    if (i != 1)
+      EXPECT_TRUE(file_util::CreateDirectory(kFSDir.Append(path)));
+  }
+  database->RemovePathForOrigin(kOrigins[0]);
+  database.reset();
+
+  const FilePath kGarbageDir = kFSDir.AppendASCII("foo");
+  const FilePath kGarbageFile = kGarbageDir.AppendASCII("bar");
+  EXPECT_TRUE(file_util::CreateDirectory(kGarbageDir));
+  bool created = false;
+  base::PlatformFileError error;
+  base::PlatformFile file = base::CreatePlatformFile(
+      kGarbageFile,
+      base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_WRITE,
+      &created, &error);
+  EXPECT_EQ(base::PLATFORM_FILE_OK, error);
+  EXPECT_TRUE(created);
+  EXPECT_TRUE(base::ClosePlatformFile(file));
+
+  CorruptDatabase(kDBDir, leveldb::kDescriptorFile, 0, 100);
+
+  const std::string kOrigin("piyo.example.org");
+  FilePath path;
+  database.reset(new FileSystemOriginDatabase(kFSDir));
+  std::vector<FileSystemOriginDatabase::OriginRecord> origins_in_db;
+  EXPECT_TRUE(database->ListAllOrigins(&origins_in_db));
+  EXPECT_EQ(arraysize(kOrigins) - 2, origins_in_db.size());
+
+  EXPECT_FALSE(database->HasOriginPath(kOrigin));
+  EXPECT_TRUE(database->GetPathForOrigin(kOrigin, &path));
+  EXPECT_FALSE(path.empty());
+  EXPECT_TRUE(database->HasOriginPath(kOrigin));
+
+  EXPECT_FALSE(file_util::PathExists(kGarbageFile));
+  EXPECT_FALSE(file_util::PathExists(kGarbageDir));
+}
+
 }  // namespace fileapi