diff options
Diffstat (limited to 'src/3rdparty/webkit/WebCore/storage/LocalStorageArea.cpp')
-rw-r--r-- | src/3rdparty/webkit/WebCore/storage/LocalStorageArea.cpp | 416 |
1 files changed, 416 insertions, 0 deletions
diff --git a/src/3rdparty/webkit/WebCore/storage/LocalStorageArea.cpp b/src/3rdparty/webkit/WebCore/storage/LocalStorageArea.cpp new file mode 100644 index 0000000..56dc246 --- /dev/null +++ b/src/3rdparty/webkit/WebCore/storage/LocalStorageArea.cpp @@ -0,0 +1,416 @@ +/* + * Copyright (C) 2008 Apple Inc. All Rights Reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "LocalStorageArea.h" + +#include "CString.h" +#include "EventNames.h" +#include "Frame.h" +#include "FrameTree.h" +#include "LocalStorage.h" +#include "LocalStorageTask.h" +#include "LocalStorageThread.h" +#include "Page.h" +#include "PageGroup.h" +#include "PlatformString.h" +#include "SecurityOrigin.h" +#include "SQLiteStatement.h" + +namespace WebCore { + +// If the LocalStorageArea undergoes rapid changes, don't sync each change to disk. +// Instead, queue up a batch of items to sync and actually do the sync at the following interval. +static const double LocalStorageSyncInterval = 1.0; + +LocalStorageArea::LocalStorageArea(SecurityOrigin* origin, LocalStorage* localStorage) + : StorageArea(origin) + , m_syncTimer(this, &LocalStorageArea::syncTimerFired) + , m_itemsCleared(false) + , m_finalSyncScheduled(false) + , m_localStorage(localStorage) + , m_clearItemsWhileSyncing(false) + , m_syncScheduled(false) + , m_importComplete(false) +{ + ASSERT(m_localStorage); + + if (!m_localStorage->scheduleImport(this)) + m_importComplete = true; +} + +LocalStorageArea::~LocalStorageArea() +{ + ASSERT(!m_syncTimer.isActive()); +} + +void LocalStorageArea::scheduleFinalSync() +{ + m_syncTimer.stop(); + syncTimerFired(&m_syncTimer); + m_finalSyncScheduled = true; +} + +unsigned LocalStorageArea::length() const +{ + ASSERT(isMainThread()); + + if (m_importComplete) + return internalLength(); + + MutexLocker locker(m_importLock); + if (m_importComplete) + return internalLength(); + + while (!m_importComplete) + m_importCondition.wait(m_importLock); + ASSERT(m_importComplete); + + return internalLength(); +} + +String LocalStorageArea::key(unsigned index, ExceptionCode& ec) const +{ + ASSERT(isMainThread()); + + if (m_importComplete) + return internalKey(index, ec); + + MutexLocker locker(m_importLock); + if (m_importComplete) + return internalKey(index, ec); + + while (!m_importComplete) + m_importCondition.wait(m_importLock); + ASSERT(m_importComplete); + + return internalKey(index, ec); +} + +String LocalStorageArea::getItem(const String& key) const +{ + ASSERT(isMainThread()); + + if (m_importComplete) + return internalGetItem(key); + + MutexLocker locker(m_importLock); + if (m_importComplete) + return internalGetItem(key); + + String item = internalGetItem(key); + if (!item.isNull()) + return item; + + while (!m_importComplete) + m_importCondition.wait(m_importLock); + ASSERT(m_importComplete); + + return internalGetItem(key); +} + +void LocalStorageArea::setItem(const String& key, const String& value, ExceptionCode& ec, Frame* frame) +{ + ASSERT(isMainThread()); + + if (m_importComplete) { + internalSetItem(key, value, ec, frame); + return; + } + + MutexLocker locker(m_importLock); + internalSetItem(key, value, ec, frame); +} + +void LocalStorageArea::removeItem(const String& key, Frame* frame) +{ + ASSERT(isMainThread()); + + if (m_importComplete) { + internalRemoveItem(key, frame); + return; + } + + MutexLocker locker(m_importLock); + internalRemoveItem(key, frame); +} + +bool LocalStorageArea::contains(const String& key) const +{ + ASSERT(isMainThread()); + + if (m_importComplete) + return internalContains(key); + + MutexLocker locker(m_importLock); + if (m_importComplete) + return internalContains(key); + + bool contained = internalContains(key); + if (contained) + return true; + + while (!m_importComplete) + m_importCondition.wait(m_importLock); + ASSERT(m_importComplete); + + return internalContains(key); +} + +void LocalStorageArea::itemChanged(const String& key, const String& oldValue, const String& newValue, Frame* sourceFrame) +{ + ASSERT(isMainThread()); + + scheduleItemForSync(key, newValue); + dispatchStorageEvent(key, oldValue, newValue, sourceFrame); +} + +void LocalStorageArea::itemRemoved(const String& key, const String& oldValue, Frame* sourceFrame) +{ + ASSERT(isMainThread()); + + scheduleItemForSync(key, String()); + dispatchStorageEvent(key, oldValue, String(), sourceFrame); +} + +void LocalStorageArea::areaCleared(Frame* sourceFrame) +{ + ASSERT(isMainThread()); + + scheduleClear(); + dispatchStorageEvent(String(), String(), String(), sourceFrame); +} + +void LocalStorageArea::dispatchStorageEvent(const String& key, const String& oldValue, const String& newValue, Frame* sourceFrame) +{ + ASSERT(isMainThread()); + + Page* page = sourceFrame->page(); + if (!page) + return; + + // Need to copy all relevant frames from every page to a vector, since sending the event to one frame might mutate the frame tree + // of any given page in the group, or mutate the page group itself + Vector<RefPtr<Frame> > frames; + const HashSet<Page*>& pages = page->group().pages(); + + HashSet<Page*>::const_iterator end = pages.end(); + for (HashSet<Page*>::const_iterator it = pages.begin(); it != end; ++it) { + for (Frame* frame = (*it)->mainFrame(); frame; frame = frame->tree()->traverseNext()) { + if (Document* document = frame->document()) + if (document->securityOrigin()->equal(securityOrigin())) + frames.append(frame); + } + } + + for (unsigned i = 0; i < frames.size(); ++i) { + if (HTMLElement* body = frames[i]->document()->body()) + body->dispatchStorageEvent(eventNames().storageEvent, key, oldValue, newValue, sourceFrame); + } +} + +void LocalStorageArea::scheduleItemForSync(const String& key, const String& value) +{ + ASSERT(isMainThread()); + ASSERT(!m_finalSyncScheduled); + + m_changedItems.set(key, value); + if (!m_syncTimer.isActive()) + m_syncTimer.startOneShot(LocalStorageSyncInterval); +} + +void LocalStorageArea::scheduleClear() +{ + ASSERT(isMainThread()); + ASSERT(!m_finalSyncScheduled); + + m_changedItems.clear(); + m_itemsCleared = true; + if (!m_syncTimer.isActive()) + m_syncTimer.startOneShot(LocalStorageSyncInterval); +} + +void LocalStorageArea::syncTimerFired(Timer<LocalStorageArea>*) +{ + ASSERT(isMainThread()); + + HashMap<String, String>::iterator it = m_changedItems.begin(); + HashMap<String, String>::iterator end = m_changedItems.end(); + + { + MutexLocker locker(m_syncLock); + + if (m_itemsCleared) { + m_itemsPendingSync.clear(); + m_clearItemsWhileSyncing = true; + m_itemsCleared = false; + } + + for (; it != end; ++it) + m_itemsPendingSync.set(it->first.copy(), it->second.copy()); + + if (!m_syncScheduled) { + m_syncScheduled = true; + m_localStorage->scheduleSync(this); + } + } + + m_changedItems.clear(); +} + +void LocalStorageArea::performImport() +{ + ASSERT(!isMainThread()); + ASSERT(!m_database.isOpen()); + + String databaseFilename = m_localStorage->fullDatabaseFilename(securityOrigin()); + + if (databaseFilename.isEmpty()) { + LOG_ERROR("Filename for local storage database is empty - cannot open for persistent storage"); + markImported(); + return; + } + + if (!m_database.open(databaseFilename)) { + LOG_ERROR("Failed to open database file %s for local storage", databaseFilename.utf8().data()); + markImported(); + return; + } + + if (!m_database.executeCommand("CREATE TABLE IF NOT EXISTS ItemTable (key TEXT UNIQUE ON CONFLICT REPLACE, value TEXT NOT NULL ON CONFLICT FAIL)")) { + LOG_ERROR("Failed to create table ItemTable for local storage"); + markImported(); + return; + } + + SQLiteStatement query(m_database, "SELECT key, value FROM ItemTable"); + if (query.prepare() != SQLResultOk) { + LOG_ERROR("Unable to select items from ItemTable for local storage"); + markImported(); + return; + } + + HashMap<String, String> itemMap; + + int result = query.step(); + while (result == SQLResultRow) { + itemMap.set(query.getColumnText(0), query.getColumnText(1)); + result = query.step(); + } + + if (result != SQLResultDone) { + LOG_ERROR("Error reading items from ItemTable for local storage"); + markImported(); + return; + } + + MutexLocker locker(m_importLock); + + HashMap<String, String>::iterator it = itemMap.begin(); + HashMap<String, String>::iterator end = itemMap.end(); + + for (; it != end; ++it) + importItem(it->first, it->second); + + m_importComplete = true; + m_importCondition.signal(); +} + +void LocalStorageArea::markImported() +{ + ASSERT(!isMainThread()); + + MutexLocker locker(m_importLock); + m_importComplete = true; + m_importCondition.signal(); +} + +void LocalStorageArea::performSync() +{ + ASSERT(!isMainThread()); + + if (!m_database.isOpen()) + return; + + HashMap<String, String> items; + bool clearFirst = false; + { + MutexLocker locker(m_syncLock); + m_itemsPendingSync.swap(items); + clearFirst = m_clearItemsWhileSyncing; + m_clearItemsWhileSyncing = false; + m_syncScheduled = false; + } + + // If the clear flag is marked, then we clear all items out before we write any new ones in + if (clearFirst) { + SQLiteStatement clear(m_database, "DELETE FROM ItemTable"); + if (clear.prepare() != SQLResultOk) { + LOG_ERROR("Failed to prepare clear statement - cannot write to local storage database"); + return; + } + + int result = clear.step(); + if (result != SQLResultDone) { + LOG_ERROR("Failed to clear all items in the local storage database - %i", result); + return; + } + } + + SQLiteStatement insert(m_database, "INSERT INTO ItemTable VALUES (?, ?)"); + if (insert.prepare() != SQLResultOk) { + LOG_ERROR("Failed to prepare insert statement - cannot write to local storage database"); + return; + } + + SQLiteStatement remove(m_database, "DELETE FROM ItemTable WHERE key=?"); + if (remove.prepare() != SQLResultOk) { + LOG_ERROR("Failed to prepare delete statement - cannot write to local storage database"); + return; + } + + HashMap<String, String>::iterator end = items.end(); + + for (HashMap<String, String>::iterator it = items.begin(); it != end; ++it) { + // Based on the null-ness of the second argument, decide whether this is an insert or a delete + SQLiteStatement& query = it->second.isNull() ? remove : insert; + + query.bindText(1, it->first); + + // If the second argument is non-null, we're doing an insert, so bind it as the value. + if (!it->second.isNull()) + query.bindText(2, it->second); + + int result = query.step(); + if (result != SQLResultDone) { + LOG_ERROR("Failed to update item in the local storage database - %i", result); + break; + } + + query.reset(); + } +} + +} // namespace WebCore |