webkit/dom_storage/dom_storage_database.cc - chromium/src - Git at Google

 // 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() {
   return new sql::DiagnosticErrorDelegate<HistogramUniquifier>();
 }

 }  // anon namespace

 namespace dom_storage {

 // static
 FilePath DomStorageDatabase::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) {
   // 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() {
   Init();
 }

 void DomStorageDatabase::Init() {
   failed_to_open_ = false;
   tried_to_recreate_ = false;
   known_to_be_empty_ = false;
 }

 DomStorageDatabase::~DomStorageDatabase() {
   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) {
   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) {
   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())
     return false;

   if (clear_all_first) {
     if (!db_->Execute("DELETE FROM ItemTable"))
       return false;
     known_to_be_empty_ = true;
   }

   bool did_delete = false;
   bool did_insert = false;
   ValuesMap::const_iterator it = changes.begin();
   for(; it != changes.end(); ++it) {
     sql::Statement statement;
     string16 key = it->first;
     NullableString16 value = it->second;
     if (value.is_null()) {
       statement.Assign(db_->GetCachedStatement(SQL_FROM_HERE,
          "DELETE FROM ItemTable WHERE key=?"));
       statement.BindString16(0, key);
       did_delete = true;
     } else {
       statement.Assign(db_->GetCachedStatement(SQL_FROM_HERE,
           "INSERT INTO ItemTable VALUES (?,?)"));
       statement.BindString16(0, key);
       statement.BindBlob(1, value.string().data(),
                          value.string().length() * sizeof(char16));
       known_to_be_empty_ = false;
       did_insert = true;
     }
     DCHECK(statement.is_valid());
     statement.Run();
   }

   if (!known_to_be_empty_ && did_delete && !did_insert) {
     sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE,
         "SELECT count(key) from ItemTable"));
     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) {
   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());

   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_)) {
       LOG(ERROR) << "Unable to open DOM storage database at "
                  << file_path_.value()
                  << " error: " << db_->GetErrorMessage();
       if (database_exists && !tried_to_recreate_)
         return DeleteFileAndRecreate();
       failed_to_open_ = true;
       return false;
     }
   }

   // sql::Connection uses UTF-8 encoding, but WebCore style databases use
   // UTF-16, so ensure we match.
   ignore_result(db_->Execute("PRAGMA encoding=\"UTF-16\""));

   if (!database_exists) {
     // This is a new database, create the table and we're done!
     if (CreateTableV2())
       return true;
   } else {
     // The database exists already - check if we need to upgrade
     // and whether it's usable (i.e. not corrupted).
     SchemaVersion current_version = DetectSchemaVersion();

     if (current_version == V2) {
       return true;
     } else if (current_version == V1) {
       if (UpgradeVersion1To2())
         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() {
   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;

   // Look at the current schema - if it doesn't look right, assume corrupt.
   if (!db_->DoesTableExist("ItemTable") ||
       !db_->DoesColumnExist("ItemTable", "key") ||
       !db_->DoesColumnExist("ItemTable", "value"))
     return INVALID;

   // We must use a unique statement here as we aren't going to step it.
   sql::Statement statement(
       db_->GetUniqueStatement("SELECT key,value from ItemTable LIMIT 1"));
   if (statement.DeclaredColumnType(0) != sql::COLUMN_TYPE_TEXT)
     return INVALID;

   switch (statement.DeclaredColumnType(1)) {
     case sql::COLUMN_TYPE_BLOB:
       return V2;
     case sql::COLUMN_TYPE_TEXT:
       return V1;
     default:
       return INVALID;
   }
   NOTREACHED();
   return INVALID;
 }

 bool DomStorageDatabase::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() {
   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() {
   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) &&
       migration.Commit();
 }

 void DomStorageDatabase::Close() {
   db_.reset(NULL);
 }

 }  // namespace dom_storage
	// 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() {
	return new sql::DiagnosticErrorDelegate<HistogramUniquifier>();
	}

	} // anon namespace

	namespace dom_storage {

	// static
	FilePath DomStorageDatabase::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) {
	// 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() {
	Init();
	}

	void DomStorageDatabase::Init() {
	failed_to_open_ = false;
	tried_to_recreate_ = false;
	known_to_be_empty_ = false;
	}

	DomStorageDatabase::~DomStorageDatabase() {
	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) {
	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) {
	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())
	return false;

	if (clear_all_first) {
	if (!db_->Execute("DELETE FROM ItemTable"))
	return false;
	known_to_be_empty_ = true;
	}

	bool did_delete = false;
	bool did_insert = false;
	ValuesMap::const_iterator it = changes.begin();
	for(; it != changes.end(); ++it) {
	sql::Statement statement;
	string16 key = it->first;
	NullableString16 value = it->second;
	if (value.is_null()) {
	statement.Assign(db_->GetCachedStatement(SQL_FROM_HERE,
	"DELETE FROM ItemTable WHERE key=?"));
	statement.BindString16(0, key);
	did_delete = true;
	} else {
	statement.Assign(db_->GetCachedStatement(SQL_FROM_HERE,
	"INSERT INTO ItemTable VALUES (?,?)"));
	statement.BindString16(0, key);
	statement.BindBlob(1, value.string().data(),
	value.string().length() * sizeof(char16));
	known_to_be_empty_ = false;
	did_insert = true;
	}
	DCHECK(statement.is_valid());
	statement.Run();
	}

	if (!known_to_be_empty_ && did_delete && !did_insert) {
	sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE,
	"SELECT count(key) from ItemTable"));
	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) {
	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());

	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_)) {
	LOG(ERROR) << "Unable to open DOM storage database at "
	<< file_path_.value()
	<< " error: " << db_->GetErrorMessage();
	if (database_exists && !tried_to_recreate_)
	return DeleteFileAndRecreate();
	failed_to_open_ = true;
	return false;
	}
	}

	// sql::Connection uses UTF-8 encoding, but WebCore style databases use
	// UTF-16, so ensure we match.
	ignore_result(db_->Execute("PRAGMA encoding=\"UTF-16\""));

	if (!database_exists) {
	// This is a new database, create the table and we're done!
	if (CreateTableV2())
	return true;
	} else {
	// The database exists already - check if we need to upgrade
	// and whether it's usable (i.e. not corrupted).
	SchemaVersion current_version = DetectSchemaVersion();

	if (current_version == V2) {
	return true;
	} else if (current_version == V1) {
	if (UpgradeVersion1To2())
	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() {
	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;

	// Look at the current schema - if it doesn't look right, assume corrupt.
	if (!db_->DoesTableExist("ItemTable") \|\|
	!db_->DoesColumnExist("ItemTable", "key") \|\|
	!db_->DoesColumnExist("ItemTable", "value"))
	return INVALID;

	// We must use a unique statement here as we aren't going to step it.
	sql::Statement statement(
	db_->GetUniqueStatement("SELECT key,value from ItemTable LIMIT 1"));
	if (statement.DeclaredColumnType(0) != sql::COLUMN_TYPE_TEXT)
	return INVALID;

	switch (statement.DeclaredColumnType(1)) {
	case sql::COLUMN_TYPE_BLOB:
	return V2;
	case sql::COLUMN_TYPE_TEXT:
	return V1;
	default:
	return INVALID;
	}
	NOTREACHED();
	return INVALID;
	}

	bool DomStorageDatabase::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() {
	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() {
	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) &&
	migration.Commit();
	}

	void DomStorageDatabase::Close() {
	db_.reset(NULL);
	}

	} // namespace dom_storage