LocalStorageDatabase.cpp [plain text]
#include "config.h"
#include "LocalStorageDatabase.h"
#include "LocalStorageDatabaseTracker.h"
#include <WebCore/FileSystem.h>
#include <WebCore/SQLiteStatement.h>
#include <WebCore/SQLiteTransaction.h>
#include <WebCore/SecurityOrigin.h>
#include <WebCore/StorageMap.h>
#include <WebCore/SuddenTermination.h>
#include <wtf/PassRefPtr.h>
#include <wtf/WorkQueue.h>
#include <wtf/text/StringHash.h>
#include <wtf/text/WTFString.h>
using namespace WebCore;
static const auto databaseUpdateInterval = std::chrono::seconds(1);
static const int maximumItemsToUpdate = 100;
namespace WebKit {
PassRefPtr<LocalStorageDatabase> LocalStorageDatabase::create(PassRefPtr<WorkQueue> queue, PassRefPtr<LocalStorageDatabaseTracker> tracker, Ref<SecurityOrigin>&& securityOrigin)
{
return adoptRef(new LocalStorageDatabase(queue, tracker, WTF::move(securityOrigin)));
}
LocalStorageDatabase::LocalStorageDatabase(PassRefPtr<WorkQueue> queue, PassRefPtr<LocalStorageDatabaseTracker> tracker, Ref<SecurityOrigin>&& securityOrigin)
: m_queue(queue)
, m_tracker(tracker)
, m_securityOrigin(WTF::move(securityOrigin))
, m_databasePath(m_tracker->databasePath(m_securityOrigin.ptr()))
, m_failedToOpenDatabase(false)
, m_didImportItems(false)
, m_isClosed(false)
, m_didScheduleDatabaseUpdate(false)
, m_shouldClearItems(false)
{
}
LocalStorageDatabase::~LocalStorageDatabase()
{
ASSERT(m_isClosed);
}
void LocalStorageDatabase::openDatabase(DatabaseOpeningStrategy openingStrategy)
{
ASSERT(!m_database.isOpen());
ASSERT(!m_failedToOpenDatabase);
if (!tryToOpenDatabase(openingStrategy)) {
m_failedToOpenDatabase = true;
return;
}
if (m_database.isOpen())
m_tracker->didOpenDatabaseWithOrigin(m_securityOrigin.ptr());
}
bool LocalStorageDatabase::tryToOpenDatabase(DatabaseOpeningStrategy openingStrategy)
{
if (!fileExists(m_databasePath) && openingStrategy == SkipIfNonExistent)
return true;
if (m_databasePath.isEmpty()) {
LOG_ERROR("Filename for local storage database is empty - cannot open for persistent storage");
return false;
}
if (!m_database.open(m_databasePath)) {
LOG_ERROR("Failed to open database file %s for local storage", m_databasePath.utf8().data());
return false;
}
m_database.disableThreadingChecks();
if (!migrateItemTableIfNeeded()) {
if (!m_database.executeCommand("DROP TABLE ItemTable"))
LOG_ERROR("Failed to delete table ItemTable for local storage");
}
if (!m_database.executeCommand("CREATE TABLE IF NOT EXISTS ItemTable (key TEXT UNIQUE ON CONFLICT REPLACE, value BLOB NOT NULL ON CONFLICT FAIL)")) {
LOG_ERROR("Failed to create table ItemTable for local storage");
return false;
}
return true;
}
bool LocalStorageDatabase::migrateItemTableIfNeeded()
{
if (!m_database.tableExists("ItemTable"))
return true;
SQLiteStatement query(m_database, "SELECT value FROM ItemTable LIMIT 1");
if (query.isColumnDeclaredAsBlob(0))
return true;
static const char* commands[] = {
"DROP TABLE IF EXISTS ItemTable2",
"CREATE TABLE ItemTable2 (key TEXT UNIQUE ON CONFLICT REPLACE, value BLOB NOT NULL ON CONFLICT FAIL)",
"INSERT INTO ItemTable2 SELECT * from ItemTable",
"DROP TABLE ItemTable",
"ALTER TABLE ItemTable2 RENAME TO ItemTable",
0,
};
SQLiteTransaction transaction(m_database, false);
transaction.begin();
for (size_t i = 0; commands[i]; ++i) {
if (m_database.executeCommand(commands[i]))
continue;
LOG_ERROR("Failed to migrate table ItemTable for local storage when executing: %s", commands[i]);
transaction.rollback();
return false;
}
transaction.commit();
return true;
}
void LocalStorageDatabase::importItems(StorageMap& storageMap)
{
if (m_didImportItems)
return;
m_didImportItems = true;
openDatabase(SkipIfNonExistent);
if (!m_database.isOpen())
return;
SQLiteStatement query(m_database, "SELECT key, value FROM ItemTable");
if (query.prepare() != SQLITE_OK) {
LOG_ERROR("Unable to select items from ItemTable for local storage");
return;
}
HashMap<String, String> items;
int result = query.step();
while (result == SQLITE_ROW) {
items.set(query.getColumnText(0), query.getColumnBlobAsString(1));
result = query.step();
}
if (result != SQLITE_DONE) {
LOG_ERROR("Error reading items from ItemTable for local storage");
return;
}
storageMap.importItems(items);
}
void LocalStorageDatabase::setItem(const String& key, const String& value)
{
itemDidChange(key, value);
}
void LocalStorageDatabase::removeItem(const String& key)
{
itemDidChange(key, String());
}
void LocalStorageDatabase::clear()
{
m_changedItems.clear();
m_shouldClearItems = true;
scheduleDatabaseUpdate();
}
void LocalStorageDatabase::close()
{
ASSERT(!m_isClosed);
m_isClosed = true;
if (m_didScheduleDatabaseUpdate) {
updateDatabaseWithChangedItems(m_changedItems);
m_changedItems.clear();
}
bool isEmpty = databaseIsEmpty();
if (m_database.isOpen())
m_database.close();
if (isEmpty)
m_tracker->deleteDatabaseWithOrigin(m_securityOrigin.ptr());
}
void LocalStorageDatabase::itemDidChange(const String& key, const String& value)
{
m_changedItems.set(key, value);
scheduleDatabaseUpdate();
}
void LocalStorageDatabase::scheduleDatabaseUpdate()
{
if (m_didScheduleDatabaseUpdate)
return;
if (!m_disableSuddenTerminationWhileWritingToLocalStorage)
m_disableSuddenTerminationWhileWritingToLocalStorage = std::make_unique<SuddenTerminationDisabler>();
m_didScheduleDatabaseUpdate = true;
RefPtr<LocalStorageDatabase> localStorageDatabase(this);
m_queue->dispatchAfter(databaseUpdateInterval, [localStorageDatabase] {
localStorageDatabase->updateDatabase();
});
}
void LocalStorageDatabase::updateDatabase()
{
if (m_isClosed)
return;
ASSERT(m_didScheduleDatabaseUpdate);
m_didScheduleDatabaseUpdate = false;
HashMap<String, String> changedItems;
if (m_changedItems.size() <= maximumItemsToUpdate) {
m_changedItems.swap(changedItems);
updateDatabaseWithChangedItems(changedItems);
m_disableSuddenTerminationWhileWritingToLocalStorage = nullptr;
} else {
for (int i = 0; i < maximumItemsToUpdate; ++i) {
auto it = m_changedItems.begin();
changedItems.add(it->key, it->value);
m_changedItems.remove(it);
}
ASSERT(changedItems.size() <= maximumItemsToUpdate);
scheduleDatabaseUpdate();
updateDatabaseWithChangedItems(changedItems);
}
}
void LocalStorageDatabase::updateDatabaseWithChangedItems(const HashMap<String, String>& changedItems)
{
if (!m_database.isOpen())
openDatabase(CreateIfNonExistent);
if (!m_database.isOpen())
return;
if (m_shouldClearItems) {
m_shouldClearItems = false;
SQLiteStatement clearStatement(m_database, "DELETE FROM ItemTable");
if (clearStatement.prepare() != SQLITE_OK) {
LOG_ERROR("Failed to prepare clear statement - cannot write to local storage database");
return;
}
int result = clearStatement.step();
if (result != SQLITE_DONE) {
LOG_ERROR("Failed to clear all items in the local storage database - %i", result);
return;
}
}
SQLiteStatement insertStatement(m_database, "INSERT INTO ItemTable VALUES (?, ?)");
if (insertStatement.prepare() != SQLITE_OK) {
LOG_ERROR("Failed to prepare insert statement - cannot write to local storage database");
return;
}
SQLiteStatement deleteStatement(m_database, "DELETE FROM ItemTable WHERE key=?");
if (deleteStatement.prepare() != SQLITE_OK) {
LOG_ERROR("Failed to prepare delete statement - cannot write to local storage database");
return;
}
SQLiteTransaction transaction(m_database);
transaction.begin();
for (auto it = changedItems.begin(), end = changedItems.end(); it != end; ++it) {
SQLiteStatement& statement = it->value.isNull() ? deleteStatement : insertStatement;
statement.bindText(1, it->key);
if (!it->value.isNull())
statement.bindBlob(2, it->value);
int result = statement.step();
if (result != SQLITE_DONE) {
LOG_ERROR("Failed to update item in the local storage database - %i", result);
break;
}
statement.reset();
}
transaction.commit();
}
bool LocalStorageDatabase::databaseIsEmpty()
{
if (!m_database.isOpen())
return false;
SQLiteStatement query(m_database, "SELECT COUNT(*) FROM ItemTable");
if (query.prepare() != SQLITE_OK) {
LOG_ERROR("Unable to count number of rows in ItemTable for local storage");
return false;
}
int result = query.step();
if (result != SQLITE_ROW) {
LOG_ERROR("No results when counting number of rows in ItemTable for local storage");
return false;
}
return !query.getColumnInt(0);
}
}