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