Persist sessionStorage on disk.

webkit/dom_storage/dom_storage_database.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 "webkit/dom_storage/dom_storage_database.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "sql/diagnostic_error_delegate.h"
 #include "sql/statement.h"
 #include "sql/transaction.h"
 #include "third_party/sqlite/sqlite3.h"
 
 namespace {
 
 const FilePath::CharType kJournal[] = FILE_PATH_LITERAL("-journal");
 
 class HistogramUniquifier {
  public:
   static const char* name() { return "Sqlite.DomStorageDatabase.Error"; }
 };
 
-sql::ErrorDelegate* GetErrorHandlerForDomStorageDatabase() {
+sql::ErrorDelegate* GetErrorHandlerForLocalStorageDatabase() {
   return new sql::DiagnosticErrorDelegate<HistogramUniquifier>();
 }
 
 }  // anon namespace
 
 namespace dom_storage {
 
 // static
-FilePath DomStorageDatabase::GetJournalFilePath(
+FilePath LocalStorageDatabase::GetJournalFilePath(
     const FilePath& database_path) {
   FilePath::StringType journal_file_name =
       database_path.BaseName().value() + kJournal;
   return database_path.DirName().Append(journal_file_name);
 }
 
 DomStorageDatabase::DomStorageDatabase(const FilePath& file_path)
-    : file_path_(file_path) {
+    : file_path_(file_path),
+      failed_to_open_(false) { }
+
+DomStorageDatabase::~DomStorageDatabase() { }
+
+LocalStorageDatabase::LocalStorageDatabase(const FilePath& file_path)
+    : DomStorageDatabase(file_path) {
   // Note: in normal use we should never get an empty backing path here.
   // However, the unit test for this class can contruct an instance
   // with an empty path.
   Init();
 }
 
-DomStorageDatabase::DomStorageDatabase() {
+LocalStorageDatabase::LocalStorageDatabase()
+    : DomStorageDatabase(FilePath(FILE_PATH_LITERAL(""))) {
   Init();
 }
 
-void DomStorageDatabase::Init() {
+void LocalStorageDatabase::Init() {
   failed_to_open_ = false;
   tried_to_recreate_ = false;
   known_to_be_empty_ = false;
 }
 
-DomStorageDatabase::~DomStorageDatabase() {
+LocalStorageDatabase::~LocalStorageDatabase() {
   if (known_to_be_empty_ && !file_path_.empty()) {
     // Delete the db and any lingering journal file from disk.
     Close();
     file_util::Delete(file_path_, false);
     file_util::Delete(GetJournalFilePath(file_path_), false);
   }
 }
 
-void DomStorageDatabase::ReadAllValues(ValuesMap* result) {
+void LocalStorageDatabase::ReadAllValues(
+    int64 namespace_id, const GURL& origin, ValuesMap* result) {
   if (!LazyOpen(false))
     return;
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE,
                                                    "SELECT * from ItemTable"));
   DCHECK(statement.is_valid());
 
   while (statement.Step()) {
     string16 key = statement.ColumnString16(0);
     string16 value;
     statement.ColumnBlobAsString16(1, &value);
     (*result)[key] = NullableString16(value, false);
   }
   known_to_be_empty_ = result->empty();
 }
 
-bool DomStorageDatabase::CommitChanges(bool clear_all_first,
-                                       const ValuesMap& changes) {
+bool LocalStorageDatabase::CommitChanges(
+    int64 namespace_id, const GURL& origin, bool clear_all_first,
+    const ValuesMap& changes) {
   if (!LazyOpen(!changes.empty())) {
     // If we're being asked to commit changes that will result in an
     // empty database, we return true if the database file doesn't exist.
     return clear_all_first && changes.empty() &&
            !file_util::PathExists(file_path_);
   }
 
   bool old_known_to_be_empty = known_to_be_empty_;
   sql::Transaction transaction(db_.get());
   if (!transaction.Begin())
@@ skipping 36 matching lines @@
     if (statement.Step())
       known_to_be_empty_ = statement.ColumnInt(0) == 0;
   }
 
   bool success = transaction.Commit();
   if (!success)
     known_to_be_empty_ = old_known_to_be_empty;
   return success;
 }
 
-bool DomStorageDatabase::LazyOpen(bool create_if_needed) {
+bool LocalStorageDatabase::LazyOpen(bool create_if_needed) {
   if (failed_to_open_) {
     // Don't try to open a database that we know has failed
     // already.
     return false;
   }
 
   if (IsOpen())
     return true;
 
   bool database_exists = file_util::PathExists(file_path_);
 
   if (!database_exists && !create_if_needed) {
     // If the file doesn't exist already and we haven't been asked to create
     // a file on disk, then we don't bother opening the database. This means
     // we wait until we absolutely need to put something onto disk before we
     // do so.
     return false;
   }
 
   db_.reset(new sql::Connection());
-  db_->set_error_delegate(GetErrorHandlerForDomStorageDatabase());
+  db_->set_error_delegate(GetErrorHandlerForLocalStorageDatabase());
 
   if (file_path_.empty()) {
     // This code path should only be triggered by unit tests.
     if (!db_->OpenInMemory()) {
       NOTREACHED() << "Unable to open DOM storage database in memory.";
       failed_to_open_ = true;
       return false;
     }
   } else {
     if (!db_->Open(file_path_)) {
@@ skipping 27 matching lines @@
         return true;
     }
   }
 
   // This is the exceptional case - to try and recover we'll attempt
   // to delete the file and start again.
   Close();
   return DeleteFileAndRecreate();
 }
 
-DomStorageDatabase::SchemaVersion DomStorageDatabase::DetectSchemaVersion() {
+LocalStorageDatabase::SchemaVersion
+LocalStorageDatabase::DetectSchemaVersion() {
   DCHECK(IsOpen());
 
   // Connection::Open() may succeed even if the file we try and open is not a
   // database, however in the case that the database is corrupted to the point
   // that SQLite doesn't actually think it's a database,
   // sql::Connection::GetCachedStatement will DCHECK when we later try and
   // run statements. So we run a query here that will not DCHECK but fail
   // on an invalid database to verify that what we've opened is usable.
   if (db_->ExecuteAndReturnErrorCode("PRAGMA auto_vacuum") != SQLITE_OK)
     return INVALID;
@@ skipping 15 matching lines @@
       return V2;
     case sql::COLUMN_TYPE_TEXT:
       return V1;
     default:
       return INVALID;
   }
   NOTREACHED();
   return INVALID;
 }
 
-bool DomStorageDatabase::CreateTableV2() {
+bool LocalStorageDatabase::CreateTableV2() {
   DCHECK(IsOpen());
 
   return db_->Execute(
       "CREATE TABLE ItemTable ("
       "key TEXT UNIQUE ON CONFLICT REPLACE, "
       "value BLOB NOT NULL ON CONFLICT FAIL)");
 }
 
-bool DomStorageDatabase::DeleteFileAndRecreate() {
+bool LocalStorageDatabase::DeleteFileAndRecreate() {
   DCHECK(!IsOpen());
   DCHECK(file_util::PathExists(file_path_));
 
   // We should only try and do this once.
   if (tried_to_recreate_)
     return false;
 
   tried_to_recreate_ = true;
 
   // If it's not a directory and we can delete the file, try and open it again.
   if (!file_util::DirectoryExists(file_path_) &&
       file_util::Delete(file_path_, false))
     return LazyOpen(true);
 
   failed_to_open_ = true;
   return false;
 }
 
-bool DomStorageDatabase::UpgradeVersion1To2() {
+bool LocalStorageDatabase::UpgradeVersion1To2() {
   DCHECK(IsOpen());
   DCHECK(DetectSchemaVersion() == V1);
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE,
       "SELECT * FROM ItemTable"));
   DCHECK(statement.is_valid());
 
   // Need to migrate from TEXT value column to BLOB.
   // Store the current database content so we can re-insert
   // the data into the new V2 table.
   ValuesMap values;
   while (statement.Step()) {
     string16 key = statement.ColumnString16(0);
     NullableString16 value(statement.ColumnString16(1), false);
     values[key] = value;
   }
 
   sql::Transaction migration(db_.get());
   return migration.Begin() &&
       db_->Execute("DROP TABLE ItemTable") &&
       CreateTableV2() &&
-      CommitChanges(false, values) &&
+      CommitChanges(0, GURL(""), false, values) &&
       migration.Commit();
 }
 
-void DomStorageDatabase::Close() {
+bool LocalStorageDatabase::IsOpen() const {
+  return db_.get() ? db_->is_open() : false;
+}
+
+void LocalStorageDatabase::Close() {
   db_.reset(NULL);
 }
 
 }  // namespace dom_storage