WebCore/storage/StorageAreaSync.cpp

   1 /*
   2  * Copyright (C) 2008, 2009 Apple Inc. All Rights Reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27 #include "StorageAreaSync.h"
  28
  29 #if ENABLE(DOM_STORAGE)
  30
  31 #include "CString.h"
  32 #include "EventNames.h"
  33 #include "HTMLElement.h"
  34 #include "SQLiteStatement.h"
  35 #include "StorageArea.h"
  36 #include "SuddenTermination.h"
  37
  38 namespace WebCore {
  39
  40 // If the StorageArea undergoes rapid changes, don't sync each change to disk.
  41 // Instead, queue up a batch of items to sync and actually do the sync at the following interval.
  42 static const double StorageSyncInterval = 1.0;
  43
  44 PassRefPtr<StorageAreaSync> StorageAreaSync::create(PassRefPtr<StorageSyncManager> storageSyncManager, PassRefPtr<StorageArea> storageArea)
  45 {
  46     return adoptRef(new StorageAreaSync(storageSyncManager, storageArea));
  47 }
  48
  49 StorageAreaSync::StorageAreaSync(PassRefPtr<StorageSyncManager> storageSyncManager, PassRefPtr<StorageArea> storageArea)
  50     : m_syncTimer(this, &StorageAreaSync::syncTimerFired)
  51     , m_itemsCleared(false)
  52     , m_finalSyncScheduled(false)
  53     , m_storageArea(storageArea)
  54     , m_syncManager(storageSyncManager)
  55     , m_clearItemsWhileSyncing(false)
  56     , m_syncScheduled(false)
  57     , m_importComplete(false)
  58 {
  59     ASSERT(m_storageArea);
  60     ASSERT(m_syncManager);
  61
  62     // FIXME: If it can't import, then the default WebKit behavior should be that of private browsing,
  63     // not silently ignoring it.  https://bugs.webkit.org/show_bug.cgi?id=25894
  64     if (!m_syncManager->scheduleImport(this))
  65         m_importComplete = true;
  66 }
  67
  68 #ifndef NDEBUG
  69 StorageAreaSync::~StorageAreaSync()
  70 {
  71     ASSERT(!m_syncTimer.isActive());
  72 }
  73 #endif
  74
  75 void StorageAreaSync::scheduleFinalSync()
  76 {
  77     ASSERT(isMainThread());
  78     // FIXME: We do this to avoid races, but it'd be better to make things safe without blocking.
  79     blockUntilImportComplete();
  80
  81     if (m_syncTimer.isActive())
  82         m_syncTimer.stop();
  83     else {
  84         // The following is balanced by the call to enableSuddenTermination in the
  85         // syncTimerFired function.
  86         disableSuddenTermination();
  87     }
  88     // FIXME: This is synchronous.  We should do it on the background process, but
  89     // we should do it safely.
  90     syncTimerFired(&m_syncTimer);
  91     m_finalSyncScheduled = true;
  92 }
  93
  94 void StorageAreaSync::scheduleItemForSync(const String& key, const String& value)
  95 {
  96     ASSERT(isMainThread());
  97     ASSERT(!m_finalSyncScheduled);
  98
  99     m_changedItems.set(key, value);
 100     if (!m_syncTimer.isActive()) {
 101         m_syncTimer.startOneShot(StorageSyncInterval);
 102
 103         // The following is balanced by the call to enableSuddenTermination in the
 104         // syncTimerFired function.
 105         disableSuddenTermination();
 106     }
 107 }
 108
 109 void StorageAreaSync::scheduleClear()
 110 {
 111     ASSERT(isMainThread());
 112     ASSERT(!m_finalSyncScheduled);
 113
 114     m_changedItems.clear();
 115     m_itemsCleared = true;
 116     if (!m_syncTimer.isActive()) {
 117         m_syncTimer.startOneShot(StorageSyncInterval);
 118
 119         // The following is balanced by the call to enableSuddenTermination in the
 120         // syncTimerFired function.
 121         disableSuddenTermination();
 122     }
 123 }
 124
 125 void StorageAreaSync::syncTimerFired(Timer<StorageAreaSync>*)
 126 {
 127     ASSERT(isMainThread());
 128
 129     HashMap<String, String>::iterator it = m_changedItems.begin();
 130     HashMap<String, String>::iterator end = m_changedItems.end();
 131
 132     {
 133         MutexLocker locker(m_syncLock);
 134
 135         if (m_itemsCleared) {
 136             m_itemsPendingSync.clear();
 137             m_clearItemsWhileSyncing = true;
 138             m_itemsCleared = false;
 139         }
 140
 141         for (; it != end; ++it)
 142             m_itemsPendingSync.set(it->first.copy(), it->second.copy());
 143
 144         if (!m_syncScheduled) {
 145             m_syncScheduled = true;
 146
 147             // The following is balanced by the call to enableSuddenTermination in the
 148             // performSync function.
 149             disableSuddenTermination();
 150
 151             m_syncManager->scheduleSync(this);
 152         }
 153     }
 154
 155     // The following is balanced by the calls to disableSuddenTermination in the
 156     // scheduleItemForSync, scheduleClear, and scheduleFinalSync functions.
 157     enableSuddenTermination();
 158
 159     m_changedItems.clear();
 160 }
 161
 162 void StorageAreaSync::performImport()
 163 {
 164     ASSERT(!isMainThread());
 165     ASSERT(!m_database.isOpen());
 166
 167     String databaseFilename = m_syncManager->fullDatabaseFilename(m_storageArea->securityOrigin());
 168
 169     if (databaseFilename.isEmpty()) {
 170         LOG_ERROR("Filename for local storage database is empty - cannot open for persistent storage");
 171         markImported();
 172         return;
 173     }
 174
 175     if (!m_database.open(databaseFilename)) {
 176         LOG_ERROR("Failed to open database file %s for local storage", databaseFilename.utf8().data());
 177         markImported();
 178         return;
 179     }
 180
 181     if (!m_database.executeCommand("CREATE TABLE IF NOT EXISTS ItemTable (key TEXT UNIQUE ON CONFLICT REPLACE, value TEXT NOT NULL ON CONFLICT FAIL)")) {
 182         LOG_ERROR("Failed to create table ItemTable for local storage");
 183         markImported();
 184         return;
 185     }
 186
 187     SQLiteStatement query(m_database, "SELECT key, value FROM ItemTable");
 188     if (query.prepare() != SQLResultOk) {
 189         LOG_ERROR("Unable to select items from ItemTable for local storage");
 190         markImported();
 191         return;
 192     }
 193
 194     HashMap<String, String> itemMap;
 195
 196     int result = query.step();
 197     while (result == SQLResultRow) {
 198         itemMap.set(query.getColumnText(0), query.getColumnText(1));
 199         result = query.step();
 200     }
 201
 202     if (result != SQLResultDone) {
 203         LOG_ERROR("Error reading items from ItemTable for local storage");
 204         markImported();
 205         return;
 206     }
 207
 208     MutexLocker locker(m_importLock);
 209
 210     HashMap<String, String>::iterator it = itemMap.begin();
 211     HashMap<String, String>::iterator end = itemMap.end();
 212
 213     for (; it != end; ++it)
 214         m_storageArea->importItem(it->first, it->second);
 215
 216     // Break the (ref count) cycle.
 217     m_storageArea = 0;
 218     m_importComplete = true;
 219     m_importCondition.signal();
 220 }
 221
 222 void StorageAreaSync::markImported()
 223 {
 224     ASSERT(!isMainThread());
 225
 226     MutexLocker locker(m_importLock);
 227     // Break the (ref count) cycle.
 228     m_storageArea = 0;
 229     m_importComplete = true;
 230     m_importCondition.signal();
 231 }
 232
 233 // FIXME: In the future, we should allow use of StorageAreas while it's importing (when safe to do so).
 234 // Blocking everything until the import is complete is by far the simplest and safest thing to do, but
 235 // there is certainly room for safe optimization: Key/length will never be able to make use of such an
 236 // optimization (since the order of iteration can change as items are being added). Get can return any
 237 // item currently in the map. Get/remove can work whether or not it's in the map, but we'll need a list
 238 // of items the import should not overwrite. Clear can also work, but it'll need to kill the import
 239 // job first.
 240 void StorageAreaSync::blockUntilImportComplete() const
 241 {
 242     ASSERT(isMainThread());
 243
 244     // Fast path to avoid locking.
 245     if (m_importComplete)
 246         return;
 247
 248     MutexLocker locker(m_importLock);
 249     while (!m_importComplete)
 250         m_importCondition.wait(m_importLock);
 251     ASSERT(m_importComplete);
 252     ASSERT(!m_storageArea);
 253 }
 254
 255 void StorageAreaSync::sync(bool clearItems, const HashMap<String, String>& items)
 256 {
 257     ASSERT(!isMainThread());
 258
 259     if (!m_database.isOpen())
 260         return;
 261
 262     // If the clear flag is set, then we clear all items out before we write any new ones in.
 263     if (clearItems) {
 264         SQLiteStatement clear(m_database, "DELETE FROM ItemTable");
 265         if (clear.prepare() != SQLResultOk) {
 266             LOG_ERROR("Failed to prepare clear statement - cannot write to local storage database");
 267             return;
 268         }
 269
 270         int result = clear.step();
 271         if (result != SQLResultDone) {
 272             LOG_ERROR("Failed to clear all items in the local storage database - %i", result);
 273             return;
 274         }
 275     }
 276
 277     SQLiteStatement insert(m_database, "INSERT INTO ItemTable VALUES (?, ?)");
 278     if (insert.prepare() != SQLResultOk) {
 279         LOG_ERROR("Failed to prepare insert statement - cannot write to local storage database");
 280         return;
 281     }
 282
 283     SQLiteStatement remove(m_database, "DELETE FROM ItemTable WHERE key=?");
 284     if (remove.prepare() != SQLResultOk) {
 285         LOG_ERROR("Failed to prepare delete statement - cannot write to local storage database");
 286         return;
 287     }
 288
 289     HashMap<String, String>::const_iterator end = items.end();
 290
 291     for (HashMap<String, String>::const_iterator it = items.begin(); it != end; ++it) {
 292         // Based on the null-ness of the second argument, decide whether this is an insert or a delete.
 293         SQLiteStatement& query = it->second.isNull() ? remove : insert;
 294
 295         query.bindText(1, it->first);
 296
 297         // If the second argument is non-null, we're doing an insert, so bind it as the value.
 298         if (!it->second.isNull())
 299             query.bindText(2, it->second);
 300
 301         int result = query.step();
 302         if (result != SQLResultDone) {
 303             LOG_ERROR("Failed to update item in the local storage database - %i", result);
 304             break;
 305         }
 306
 307         query.reset();
 308     }
 309 }
 310
 311 void StorageAreaSync::performSync()
 312 {
 313     ASSERT(!isMainThread());
 314
 315     bool clearItems;
 316     HashMap<String, String> items;
 317     {
 318         MutexLocker locker(m_syncLock);
 319
 320         ASSERT(m_syncScheduled);
 321
 322         clearItems = m_clearItemsWhileSyncing;
 323         m_itemsPendingSync.swap(items);
 324
 325         m_clearItemsWhileSyncing = false;
 326         m_syncScheduled = false;
 327     }
 328
 329     sync(clearItems, items);
 330
 331     // The following is balanced by the call to disableSuddenTermination in the
 332     // syncTimerFired function.
 333     enableSuddenTermination();
 334 }
 335
 336 } // namespace WebCore
 337
 338 #endif // ENABLE(DOM_STORAGE)
 339