<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[196735] trunk/Source/WebKit2</title>
</head>
<body>
<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; }
#msg dl a { font-weight: bold}
#msg dl a:link { color:#fc3; }
#msg dl a:active { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/196735">196735</a></dd>
<dt>Author</dt> <dd>beidson@apple.com</dd>
<dt>Date</dt> <dd>2016-02-17 17:25:21 -0800 (Wed, 17 Feb 2016)</dd>
</dl>
<h3>Log Message</h3>
<pre>Modern IDB: Rename some "UniqueIDBDatabase" classes that conflict with new classes in WebCore.
https://bugs.webkit.org/show_bug.cgi?id=154363.
Reviewed by Alex Christensen.
Adding "Legacy" to the front of the name fixes problems for now.
And all of this gunk will go away after Modern IDB is done, anyways.
* CMakeLists.txt:
* DatabaseProcess/DatabaseProcess.cpp:
(WebKit::DatabaseProcess::getOrCreateLegacyUniqueIDBDatabase):
(WebKit::DatabaseProcess::removeLegacyUniqueIDBDatabase):
(WebKit::DatabaseProcess::getOrCreateUniqueIDBDatabase): Deleted.
(WebKit::DatabaseProcess::removeUniqueIDBDatabase): Deleted.
* DatabaseProcess/DatabaseProcess.h:
* DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.cpp:
(WebKit::DatabaseProcessIDBConnection::establishConnection):
* DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.h:
* DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabase.cpp: Renamed from Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabase.cpp.
(WebKit::LegacyUniqueIDBDatabase::calculateAbsoluteDatabaseFilename):
(WebKit::LegacyUniqueIDBDatabase::LegacyUniqueIDBDatabase):
(WebKit::LegacyUniqueIDBDatabase::~LegacyUniqueIDBDatabase):
(WebKit::LegacyUniqueIDBDatabase::filenameForDatabaseName):
(WebKit::LegacyUniqueIDBDatabase::databaseFilenameIdentifier):
(WebKit::LegacyUniqueIDBDatabase::canShareDatabases):
(WebKit::LegacyUniqueIDBDatabase::registerConnection):
(WebKit::LegacyUniqueIDBDatabase::unregisterConnection):
(WebKit::LegacyUniqueIDBDatabase::shutdown):
(WebKit::LegacyUniqueIDBDatabase::shutdownBackingStore):
(WebKit::LegacyUniqueIDBDatabase::didShutdownBackingStore):
(WebKit::LegacyUniqueIDBDatabase::deleteDatabase):
(WebKit::LegacyUniqueIDBDatabase::getOrEstablishIDBDatabaseMetadata):
(WebKit::LegacyUniqueIDBDatabase::openBackingStoreAndReadMetadata):
(WebKit::LegacyUniqueIDBDatabase::didOpenBackingStoreAndReadMetadata):
(WebKit::LegacyUniqueIDBDatabase::openTransaction):
(WebKit::LegacyUniqueIDBDatabase::beginTransaction):
(WebKit::LegacyUniqueIDBDatabase::commitTransaction):
(WebKit::LegacyUniqueIDBDatabase::resetTransaction):
(WebKit::LegacyUniqueIDBDatabase::rollbackTransaction):
(WebKit::LegacyUniqueIDBDatabase::postTransactionOperation):
(WebKit::LegacyUniqueIDBDatabase::didCompleteTransactionOperation):
(WebKit::LegacyUniqueIDBDatabase::changeDatabaseVersion):
(WebKit::LegacyUniqueIDBDatabase::didChangeDatabaseVersion):
(WebKit::LegacyUniqueIDBDatabase::didCreateObjectStore):
(WebKit::LegacyUniqueIDBDatabase::didDeleteObjectStore):
(WebKit::LegacyUniqueIDBDatabase::didClearObjectStore):
(WebKit::LegacyUniqueIDBDatabase::didCreateIndex):
(WebKit::LegacyUniqueIDBDatabase::didDeleteIndex):
(WebKit::LegacyUniqueIDBDatabase::didCompleteBoolRequest):
(WebKit::LegacyUniqueIDBDatabase::createObjectStore):
(WebKit::LegacyUniqueIDBDatabase::deleteObjectStore):
(WebKit::LegacyUniqueIDBDatabase::clearObjectStore):
(WebKit::LegacyUniqueIDBDatabase::createIndex):
(WebKit::LegacyUniqueIDBDatabase::deleteIndex):
(WebKit::LegacyUniqueIDBDatabase::putRecord):
(WebKit::LegacyUniqueIDBDatabase::getRecord):
(WebKit::LegacyUniqueIDBDatabase::openCursor):
(WebKit::LegacyUniqueIDBDatabase::cursorAdvance):
(WebKit::LegacyUniqueIDBDatabase::cursorIterate):
(WebKit::LegacyUniqueIDBDatabase::count):
(WebKit::LegacyUniqueIDBDatabase::deleteRange):
(WebKit::LegacyUniqueIDBDatabase::openBackingStoreTransaction):
(WebKit::LegacyUniqueIDBDatabase::beginBackingStoreTransaction):
(WebKit::LegacyUniqueIDBDatabase::commitBackingStoreTransaction):
(WebKit::LegacyUniqueIDBDatabase::resetBackingStoreTransaction):
(WebKit::LegacyUniqueIDBDatabase::rollbackBackingStoreTransaction):
(WebKit::LegacyUniqueIDBDatabase::changeDatabaseVersionInBackingStore):
(WebKit::LegacyUniqueIDBDatabase::createObjectStoreInBackingStore):
(WebKit::LegacyUniqueIDBDatabase::deleteObjectStoreInBackingStore):
(WebKit::LegacyUniqueIDBDatabase::clearObjectStoreInBackingStore):
(WebKit::LegacyUniqueIDBDatabase::createIndexInBackingStore):
(WebKit::LegacyUniqueIDBDatabase::deleteIndexInBackingStore):
(WebKit::LegacyUniqueIDBDatabase::putRecordInBackingStore):
(WebKit::LegacyUniqueIDBDatabase::didPutRecordInBackingStore):
(WebKit::LegacyUniqueIDBDatabase::getRecordFromBackingStore):
(WebKit::LegacyUniqueIDBDatabase::didGetRecordFromBackingStore):
(WebKit::LegacyUniqueIDBDatabase::openCursorInBackingStore):
(WebKit::LegacyUniqueIDBDatabase::didOpenCursorInBackingStore):
(WebKit::LegacyUniqueIDBDatabase::advanceCursorInBackingStore):
(WebKit::LegacyUniqueIDBDatabase::didAdvanceCursorInBackingStore):
(WebKit::LegacyUniqueIDBDatabase::iterateCursorInBackingStore):
(WebKit::LegacyUniqueIDBDatabase::didIterateCursorInBackingStore):
(WebKit::LegacyUniqueIDBDatabase::countInBackingStore):
(WebKit::LegacyUniqueIDBDatabase::didCountInBackingStore):
(WebKit::LegacyUniqueIDBDatabase::deleteRangeInBackingStore):
(WebKit::LegacyUniqueIDBDatabase::didDeleteRangeInBackingStore):
(WebKit::LegacyUniqueIDBDatabase::didEstablishTransaction):
(WebKit::LegacyUniqueIDBDatabase::didResetTransaction):
(WebKit::LegacyUniqueIDBDatabase::resetAllTransactions):
(WebKit::LegacyUniqueIDBDatabase::finalizeRollback):
(WebKit::LegacyUniqueIDBDatabase::absoluteDatabaseDirectory):
(WebKit::LegacyUniqueIDBDatabase::postMainThreadTask):
(WebKit::LegacyUniqueIDBDatabase::performNextMainThreadTask):
(WebKit::LegacyUniqueIDBDatabase::postDatabaseTask):
(WebKit::LegacyUniqueIDBDatabase::performNextDatabaseTask):
* DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabase.h: Renamed from Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabase.h.
(WebKit::LegacyUniqueIDBDatabase::create):
(WebKit::LegacyUniqueIDBDatabase::identifier):
* DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabaseIdentifier.cpp: Renamed from Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabaseIdentifier.cpp.
(WebKit::LegacyUniqueIDBDatabaseIdentifier::LegacyUniqueIDBDatabaseIdentifier):
(WebKit::LegacyUniqueIDBDatabaseIdentifier::isHashTableDeletedValue):
(WebKit::LegacyUniqueIDBDatabaseIdentifier::hash):
(WebKit::LegacyUniqueIDBDatabaseIdentifier::isNull):
(WebKit::LegacyUniqueIDBDatabaseIdentifier::isolatedCopy):
(WebKit::operator==):
* DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabaseIdentifier.h: Renamed from Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabaseIdentifier.h.
(WebKit::LegacyUniqueIDBDatabaseIdentifier::databaseName):
(WebKit::LegacyUniqueIDBDatabaseIdentifier::openingOrigin):
(WebKit::LegacyUniqueIDBDatabaseIdentifier::mainFrameOrigin):
(WebKit::LegacyUniqueIDBDatabaseIdentifierHash::hash):
(WebKit::LegacyUniqueIDBDatabaseIdentifierHash::equal):
(WebKit::LegacyUniqueIDBDatabaseIdentifierHashTraits::isEmptyValue):
* DatabaseProcess/IndexedDB/sqlite/UniqueIDBDatabaseBackingStoreSQLite.cpp:
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::UniqueIDBDatabaseBackingStoreSQLite):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::getOrEstablishMetadata):
* DatabaseProcess/IndexedDB/sqlite/UniqueIDBDatabaseBackingStoreSQLite.h:
* Shared/WebCrossThreadCopier.cpp:
(WebCore::LegacyUniqueIDBDatabaseIdentifier>::copy):
(WebCore::UniqueIDBDatabaseIdentifier>::copy): Deleted.
* Shared/WebCrossThreadCopier.h:
* WebKit2.xcodeproj/project.pbxproj:</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkSourceWebKit2CMakeListstxt">trunk/Source/WebKit2/CMakeLists.txt</a></li>
<li><a href="#trunkSourceWebKit2ChangeLog">trunk/Source/WebKit2/ChangeLog</a></li>
<li><a href="#trunkSourceWebKit2DatabaseProcessDatabaseProcesscpp">trunk/Source/WebKit2/DatabaseProcess/DatabaseProcess.cpp</a></li>
<li><a href="#trunkSourceWebKit2DatabaseProcessDatabaseProcessh">trunk/Source/WebKit2/DatabaseProcess/DatabaseProcess.h</a></li>
<li><a href="#trunkSourceWebKit2DatabaseProcessIndexedDBDatabaseProcessIDBConnectioncpp">trunk/Source/WebKit2/DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.cpp</a></li>
<li><a href="#trunkSourceWebKit2DatabaseProcessIndexedDBDatabaseProcessIDBConnectionh">trunk/Source/WebKit2/DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.h</a></li>
<li><a href="#trunkSourceWebKit2DatabaseProcessIndexedDBsqliteUniqueIDBDatabaseBackingStoreSQLitecpp">trunk/Source/WebKit2/DatabaseProcess/IndexedDB/sqlite/UniqueIDBDatabaseBackingStoreSQLite.cpp</a></li>
<li><a href="#trunkSourceWebKit2DatabaseProcessIndexedDBsqliteUniqueIDBDatabaseBackingStoreSQLiteh">trunk/Source/WebKit2/DatabaseProcess/IndexedDB/sqlite/UniqueIDBDatabaseBackingStoreSQLite.h</a></li>
<li><a href="#trunkSourceWebKit2SharedWebCrossThreadCopiercpp">trunk/Source/WebKit2/Shared/WebCrossThreadCopier.cpp</a></li>
<li><a href="#trunkSourceWebKit2SharedWebCrossThreadCopierh">trunk/Source/WebKit2/Shared/WebCrossThreadCopier.h</a></li>
<li><a href="#trunkSourceWebKit2WebKit2xcodeprojprojectpbxproj">trunk/Source/WebKit2/WebKit2.xcodeproj/project.pbxproj</a></li>
</ul>
<h3>Added Paths</h3>
<ul>
<li><a href="#trunkSourceWebKit2DatabaseProcessIndexedDBLegacyUniqueIDBDatabasecpp">trunk/Source/WebKit2/DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabase.cpp</a></li>
<li><a href="#trunkSourceWebKit2DatabaseProcessIndexedDBLegacyUniqueIDBDatabaseh">trunk/Source/WebKit2/DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabase.h</a></li>
<li><a href="#trunkSourceWebKit2DatabaseProcessIndexedDBLegacyUniqueIDBDatabaseIdentifiercpp">trunk/Source/WebKit2/DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabaseIdentifier.cpp</a></li>
<li><a href="#trunkSourceWebKit2DatabaseProcessIndexedDBLegacyUniqueIDBDatabaseIdentifierh">trunk/Source/WebKit2/DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabaseIdentifier.h</a></li>
</ul>
<h3>Removed Paths</h3>
<ul>
<li><a href="#trunkSourceWebKit2DatabaseProcessIndexedDBUniqueIDBDatabasecpp">trunk/Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabase.cpp</a></li>
<li><a href="#trunkSourceWebKit2DatabaseProcessIndexedDBUniqueIDBDatabaseh">trunk/Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabase.h</a></li>
<li><a href="#trunkSourceWebKit2DatabaseProcessIndexedDBUniqueIDBDatabaseIdentifiercpp">trunk/Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabaseIdentifier.cpp</a></li>
<li><a href="#trunkSourceWebKit2DatabaseProcessIndexedDBUniqueIDBDatabaseIdentifierh">trunk/Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabaseIdentifier.h</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkSourceWebKit2CMakeListstxt"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebKit2/CMakeLists.txt (196734 => 196735)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit2/CMakeLists.txt 2016-02-18 01:17:36 UTC (rev 196734)
+++ trunk/Source/WebKit2/CMakeLists.txt 2016-02-18 01:25:21 UTC (rev 196735)
</span><span class="lines">@@ -196,8 +196,8 @@
</span><span class="cx">
</span><span class="cx"> DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.cpp
</span><span class="cx"> DatabaseProcess/IndexedDB/IDBSerialization.cpp
</span><del>- DatabaseProcess/IndexedDB/UniqueIDBDatabase.cpp
- DatabaseProcess/IndexedDB/UniqueIDBDatabaseIdentifier.cpp
</del><ins>+ DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabase.cpp
+ DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabaseIdentifier.cpp
</ins><span class="cx"> DatabaseProcess/IndexedDB/WebIDBConnectionToClient.cpp
</span><span class="cx">
</span><span class="cx"> DatabaseProcess/IndexedDB/sqlite/SQLiteIDBCursor.cpp
</span></span></pre></div>
<a id="trunkSourceWebKit2ChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebKit2/ChangeLog (196734 => 196735)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit2/ChangeLog 2016-02-18 01:17:36 UTC (rev 196734)
+++ trunk/Source/WebKit2/ChangeLog 2016-02-18 01:25:21 UTC (rev 196735)
</span><span class="lines">@@ -1,3 +1,128 @@
</span><ins>+2016-02-17 Brady Eidson <beidson@apple.com>
+
+ Modern IDB: Rename some "UniqueIDBDatabase" classes that conflict with new classes in WebCore.
+ https://bugs.webkit.org/show_bug.cgi?id=154363.
+
+ Reviewed by Alex Christensen.
+
+ Adding "Legacy" to the front of the name fixes problems for now.
+
+ And all of this gunk will go away after Modern IDB is done, anyways.
+
+ * CMakeLists.txt:
+ * DatabaseProcess/DatabaseProcess.cpp:
+ (WebKit::DatabaseProcess::getOrCreateLegacyUniqueIDBDatabase):
+ (WebKit::DatabaseProcess::removeLegacyUniqueIDBDatabase):
+ (WebKit::DatabaseProcess::getOrCreateUniqueIDBDatabase): Deleted.
+ (WebKit::DatabaseProcess::removeUniqueIDBDatabase): Deleted.
+ * DatabaseProcess/DatabaseProcess.h:
+ * DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.cpp:
+ (WebKit::DatabaseProcessIDBConnection::establishConnection):
+ * DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.h:
+ * DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabase.cpp: Renamed from Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabase.cpp.
+ (WebKit::LegacyUniqueIDBDatabase::calculateAbsoluteDatabaseFilename):
+ (WebKit::LegacyUniqueIDBDatabase::LegacyUniqueIDBDatabase):
+ (WebKit::LegacyUniqueIDBDatabase::~LegacyUniqueIDBDatabase):
+ (WebKit::LegacyUniqueIDBDatabase::filenameForDatabaseName):
+ (WebKit::LegacyUniqueIDBDatabase::databaseFilenameIdentifier):
+ (WebKit::LegacyUniqueIDBDatabase::canShareDatabases):
+ (WebKit::LegacyUniqueIDBDatabase::registerConnection):
+ (WebKit::LegacyUniqueIDBDatabase::unregisterConnection):
+ (WebKit::LegacyUniqueIDBDatabase::shutdown):
+ (WebKit::LegacyUniqueIDBDatabase::shutdownBackingStore):
+ (WebKit::LegacyUniqueIDBDatabase::didShutdownBackingStore):
+ (WebKit::LegacyUniqueIDBDatabase::deleteDatabase):
+ (WebKit::LegacyUniqueIDBDatabase::getOrEstablishIDBDatabaseMetadata):
+ (WebKit::LegacyUniqueIDBDatabase::openBackingStoreAndReadMetadata):
+ (WebKit::LegacyUniqueIDBDatabase::didOpenBackingStoreAndReadMetadata):
+ (WebKit::LegacyUniqueIDBDatabase::openTransaction):
+ (WebKit::LegacyUniqueIDBDatabase::beginTransaction):
+ (WebKit::LegacyUniqueIDBDatabase::commitTransaction):
+ (WebKit::LegacyUniqueIDBDatabase::resetTransaction):
+ (WebKit::LegacyUniqueIDBDatabase::rollbackTransaction):
+ (WebKit::LegacyUniqueIDBDatabase::postTransactionOperation):
+ (WebKit::LegacyUniqueIDBDatabase::didCompleteTransactionOperation):
+ (WebKit::LegacyUniqueIDBDatabase::changeDatabaseVersion):
+ (WebKit::LegacyUniqueIDBDatabase::didChangeDatabaseVersion):
+ (WebKit::LegacyUniqueIDBDatabase::didCreateObjectStore):
+ (WebKit::LegacyUniqueIDBDatabase::didDeleteObjectStore):
+ (WebKit::LegacyUniqueIDBDatabase::didClearObjectStore):
+ (WebKit::LegacyUniqueIDBDatabase::didCreateIndex):
+ (WebKit::LegacyUniqueIDBDatabase::didDeleteIndex):
+ (WebKit::LegacyUniqueIDBDatabase::didCompleteBoolRequest):
+ (WebKit::LegacyUniqueIDBDatabase::createObjectStore):
+ (WebKit::LegacyUniqueIDBDatabase::deleteObjectStore):
+ (WebKit::LegacyUniqueIDBDatabase::clearObjectStore):
+ (WebKit::LegacyUniqueIDBDatabase::createIndex):
+ (WebKit::LegacyUniqueIDBDatabase::deleteIndex):
+ (WebKit::LegacyUniqueIDBDatabase::putRecord):
+ (WebKit::LegacyUniqueIDBDatabase::getRecord):
+ (WebKit::LegacyUniqueIDBDatabase::openCursor):
+ (WebKit::LegacyUniqueIDBDatabase::cursorAdvance):
+ (WebKit::LegacyUniqueIDBDatabase::cursorIterate):
+ (WebKit::LegacyUniqueIDBDatabase::count):
+ (WebKit::LegacyUniqueIDBDatabase::deleteRange):
+ (WebKit::LegacyUniqueIDBDatabase::openBackingStoreTransaction):
+ (WebKit::LegacyUniqueIDBDatabase::beginBackingStoreTransaction):
+ (WebKit::LegacyUniqueIDBDatabase::commitBackingStoreTransaction):
+ (WebKit::LegacyUniqueIDBDatabase::resetBackingStoreTransaction):
+ (WebKit::LegacyUniqueIDBDatabase::rollbackBackingStoreTransaction):
+ (WebKit::LegacyUniqueIDBDatabase::changeDatabaseVersionInBackingStore):
+ (WebKit::LegacyUniqueIDBDatabase::createObjectStoreInBackingStore):
+ (WebKit::LegacyUniqueIDBDatabase::deleteObjectStoreInBackingStore):
+ (WebKit::LegacyUniqueIDBDatabase::clearObjectStoreInBackingStore):
+ (WebKit::LegacyUniqueIDBDatabase::createIndexInBackingStore):
+ (WebKit::LegacyUniqueIDBDatabase::deleteIndexInBackingStore):
+ (WebKit::LegacyUniqueIDBDatabase::putRecordInBackingStore):
+ (WebKit::LegacyUniqueIDBDatabase::didPutRecordInBackingStore):
+ (WebKit::LegacyUniqueIDBDatabase::getRecordFromBackingStore):
+ (WebKit::LegacyUniqueIDBDatabase::didGetRecordFromBackingStore):
+ (WebKit::LegacyUniqueIDBDatabase::openCursorInBackingStore):
+ (WebKit::LegacyUniqueIDBDatabase::didOpenCursorInBackingStore):
+ (WebKit::LegacyUniqueIDBDatabase::advanceCursorInBackingStore):
+ (WebKit::LegacyUniqueIDBDatabase::didAdvanceCursorInBackingStore):
+ (WebKit::LegacyUniqueIDBDatabase::iterateCursorInBackingStore):
+ (WebKit::LegacyUniqueIDBDatabase::didIterateCursorInBackingStore):
+ (WebKit::LegacyUniqueIDBDatabase::countInBackingStore):
+ (WebKit::LegacyUniqueIDBDatabase::didCountInBackingStore):
+ (WebKit::LegacyUniqueIDBDatabase::deleteRangeInBackingStore):
+ (WebKit::LegacyUniqueIDBDatabase::didDeleteRangeInBackingStore):
+ (WebKit::LegacyUniqueIDBDatabase::didEstablishTransaction):
+ (WebKit::LegacyUniqueIDBDatabase::didResetTransaction):
+ (WebKit::LegacyUniqueIDBDatabase::resetAllTransactions):
+ (WebKit::LegacyUniqueIDBDatabase::finalizeRollback):
+ (WebKit::LegacyUniqueIDBDatabase::absoluteDatabaseDirectory):
+ (WebKit::LegacyUniqueIDBDatabase::postMainThreadTask):
+ (WebKit::LegacyUniqueIDBDatabase::performNextMainThreadTask):
+ (WebKit::LegacyUniqueIDBDatabase::postDatabaseTask):
+ (WebKit::LegacyUniqueIDBDatabase::performNextDatabaseTask):
+ * DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabase.h: Renamed from Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabase.h.
+ (WebKit::LegacyUniqueIDBDatabase::create):
+ (WebKit::LegacyUniqueIDBDatabase::identifier):
+ * DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabaseIdentifier.cpp: Renamed from Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabaseIdentifier.cpp.
+ (WebKit::LegacyUniqueIDBDatabaseIdentifier::LegacyUniqueIDBDatabaseIdentifier):
+ (WebKit::LegacyUniqueIDBDatabaseIdentifier::isHashTableDeletedValue):
+ (WebKit::LegacyUniqueIDBDatabaseIdentifier::hash):
+ (WebKit::LegacyUniqueIDBDatabaseIdentifier::isNull):
+ (WebKit::LegacyUniqueIDBDatabaseIdentifier::isolatedCopy):
+ (WebKit::operator==):
+ * DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabaseIdentifier.h: Renamed from Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabaseIdentifier.h.
+ (WebKit::LegacyUniqueIDBDatabaseIdentifier::databaseName):
+ (WebKit::LegacyUniqueIDBDatabaseIdentifier::openingOrigin):
+ (WebKit::LegacyUniqueIDBDatabaseIdentifier::mainFrameOrigin):
+ (WebKit::LegacyUniqueIDBDatabaseIdentifierHash::hash):
+ (WebKit::LegacyUniqueIDBDatabaseIdentifierHash::equal):
+ (WebKit::LegacyUniqueIDBDatabaseIdentifierHashTraits::isEmptyValue):
+ * DatabaseProcess/IndexedDB/sqlite/UniqueIDBDatabaseBackingStoreSQLite.cpp:
+ (WebKit::UniqueIDBDatabaseBackingStoreSQLite::UniqueIDBDatabaseBackingStoreSQLite):
+ (WebKit::UniqueIDBDatabaseBackingStoreSQLite::getOrEstablishMetadata):
+ * DatabaseProcess/IndexedDB/sqlite/UniqueIDBDatabaseBackingStoreSQLite.h:
+ * Shared/WebCrossThreadCopier.cpp:
+ (WebCore::LegacyUniqueIDBDatabaseIdentifier>::copy):
+ (WebCore::UniqueIDBDatabaseIdentifier>::copy): Deleted.
+ * Shared/WebCrossThreadCopier.h:
+ * WebKit2.xcodeproj/project.pbxproj:
+
</ins><span class="cx"> 2016-02-17 Anders Carlsson <andersca@apple.com>
</span><span class="cx">
</span><span class="cx"> Remove WebContextSupplement::shouldTerminate, it's no longer used
</span></span></pre></div>
<a id="trunkSourceWebKit2DatabaseProcessDatabaseProcesscpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebKit2/DatabaseProcess/DatabaseProcess.cpp (196734 => 196735)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit2/DatabaseProcess/DatabaseProcess.cpp 2016-02-18 01:17:36 UTC (rev 196734)
+++ trunk/Source/WebKit2/DatabaseProcess/DatabaseProcess.cpp 2016-02-18 01:25:21 UTC (rev 196735)
</span><span class="lines">@@ -32,7 +32,7 @@
</span><span class="cx"> #include "DatabaseProcessMessages.h"
</span><span class="cx"> #include "DatabaseProcessProxyMessages.h"
</span><span class="cx"> #include "DatabaseToWebProcessConnection.h"
</span><del>-#include "UniqueIDBDatabase.h"
</del><ins>+#include "LegacyUniqueIDBDatabase.h"
</ins><span class="cx"> #include "WebCrossThreadCopier.h"
</span><span class="cx"> #include "WebsiteData.h"
</span><span class="cx"> #include <WebCore/CrossThreadTask.h>
</span><span class="lines">@@ -96,21 +96,21 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> #if ENABLE(INDEXED_DATABASE)
</span><del>-RefPtr<UniqueIDBDatabase> DatabaseProcess::getOrCreateUniqueIDBDatabase(const UniqueIDBDatabaseIdentifier& identifier)
</del><ins>+RefPtr<LegacyUniqueIDBDatabase> DatabaseProcess::getOrCreateLegacyUniqueIDBDatabase(const LegacyUniqueIDBDatabaseIdentifier& identifier)
</ins><span class="cx"> {
</span><span class="cx"> auto addResult = m_idbDatabases.add(identifier, nullptr);
</span><span class="cx">
</span><span class="cx"> if (!addResult.isNewEntry)
</span><span class="cx"> return addResult.iterator->value;
</span><span class="cx">
</span><del>- RefPtr<UniqueIDBDatabase> database = UniqueIDBDatabase::create(identifier);
</del><ins>+ RefPtr<LegacyUniqueIDBDatabase> database = LegacyUniqueIDBDatabase::create(identifier);
</ins><span class="cx"> addResult.iterator->value = database.get();
</span><span class="cx"> return database;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void DatabaseProcess::removeUniqueIDBDatabase(const UniqueIDBDatabase& database)
</del><ins>+void DatabaseProcess::removeLegacyUniqueIDBDatabase(const LegacyUniqueIDBDatabase& database)
</ins><span class="cx"> {
</span><del>- const UniqueIDBDatabaseIdentifier& identifier = database.identifier();
</del><ins>+ const LegacyUniqueIDBDatabaseIdentifier& identifier = database.identifier();
</ins><span class="cx"> ASSERT(m_idbDatabases.contains(identifier));
</span><span class="cx">
</span><span class="cx"> m_idbDatabases.remove(identifier);
</span></span></pre></div>
<a id="trunkSourceWebKit2DatabaseProcessDatabaseProcessh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebKit2/DatabaseProcess/DatabaseProcess.h (196734 => 196735)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit2/DatabaseProcess/DatabaseProcess.h 2016-02-18 01:17:36 UTC (rev 196734)
+++ trunk/Source/WebKit2/DatabaseProcess/DatabaseProcess.h 2016-02-18 01:25:21 UTC (rev 196735)
</span><span class="lines">@@ -29,7 +29,7 @@
</span><span class="cx"> #if ENABLE(DATABASE_PROCESS)
</span><span class="cx">
</span><span class="cx"> #include "ChildProcess.h"
</span><del>-#include "UniqueIDBDatabaseIdentifier.h"
</del><ins>+#include "LegacyUniqueIDBDatabaseIdentifier.h"
</ins><span class="cx"> #include <wtf/NeverDestroyed.h>
</span><span class="cx">
</span><span class="cx"> namespace WebCore {
</span><span class="lines">@@ -41,7 +41,7 @@
</span><span class="cx"> namespace WebKit {
</span><span class="cx">
</span><span class="cx"> class DatabaseToWebProcessConnection;
</span><del>-class UniqueIDBDatabase;
</del><ins>+class LegacyUniqueIDBDatabase;
</ins><span class="cx">
</span><span class="cx"> struct DatabaseProcessCreationParameters;
</span><span class="cx">
</span><span class="lines">@@ -55,8 +55,8 @@
</span><span class="cx"> #if ENABLE(INDEXED_DATABASE)
</span><span class="cx"> const String& indexedDatabaseDirectory() const { return m_indexedDatabaseDirectory; }
</span><span class="cx">
</span><del>- RefPtr<UniqueIDBDatabase> getOrCreateUniqueIDBDatabase(const UniqueIDBDatabaseIdentifier&);
- void removeUniqueIDBDatabase(const UniqueIDBDatabase&);
</del><ins>+ RefPtr<LegacyUniqueIDBDatabase> getOrCreateLegacyUniqueIDBDatabase(const LegacyUniqueIDBDatabaseIdentifier&);
+ void removeLegacyUniqueIDBDatabase(const LegacyUniqueIDBDatabase&);
</ins><span class="cx">
</span><span class="cx"> void ensureIndexedDatabaseRelativePathExists(const String&);
</span><span class="cx"> String absoluteIndexedDatabasePathFromDatabaseRelativePath(const String&);
</span><span class="lines">@@ -109,7 +109,7 @@
</span><span class="cx"> #if ENABLE(INDEXED_DATABASE)
</span><span class="cx"> String m_indexedDatabaseDirectory;
</span><span class="cx">
</span><del>- HashMap<UniqueIDBDatabaseIdentifier, RefPtr<UniqueIDBDatabase>> m_idbDatabases;
</del><ins>+ HashMap<LegacyUniqueIDBDatabaseIdentifier, RefPtr<LegacyUniqueIDBDatabase>> m_idbDatabases;
</ins><span class="cx"> #endif
</span><span class="cx">
</span><span class="cx"> Deque<std::unique_ptr<WebCore::CrossThreadTask>> m_databaseTasks;
</span></span></pre></div>
<a id="trunkSourceWebKit2DatabaseProcessIndexedDBDatabaseProcessIDBConnectioncpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebKit2/DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.cpp (196734 => 196735)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit2/DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.cpp 2016-02-18 01:17:36 UTC (rev 196734)
+++ trunk/Source/WebKit2/DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.cpp 2016-02-18 01:25:21 UTC (rev 196735)
</span><span class="lines">@@ -33,7 +33,7 @@
</span><span class="cx"> #include "DatabaseToWebProcessConnection.h"
</span><span class="cx"> #include "IDBIdentifier.h"
</span><span class="cx"> #include "Logging.h"
</span><del>-#include "UniqueIDBDatabase.h"
</del><ins>+#include "LegacyUniqueIDBDatabase.h"
</ins><span class="cx"> #include "WebCoreArgumentCoders.h"
</span><span class="cx"> #include "WebIDBServerConnectionMessages.h"
</span><span class="cx"> #include <WebCore/IDBDatabaseMetadata.h>
</span><span class="lines">@@ -71,7 +71,7 @@
</span><span class="cx">
</span><span class="cx"> void DatabaseProcessIDBConnection::establishConnection(const String& databaseName, const SecurityOriginData& openingOrigin, const SecurityOriginData& mainFrameOrigin)
</span><span class="cx"> {
</span><del>- m_uniqueIDBDatabase = DatabaseProcess::singleton().getOrCreateUniqueIDBDatabase(UniqueIDBDatabaseIdentifier(databaseName, openingOrigin, mainFrameOrigin));
</del><ins>+ m_uniqueIDBDatabase = DatabaseProcess::singleton().getOrCreateLegacyUniqueIDBDatabase(LegacyUniqueIDBDatabaseIdentifier(databaseName, openingOrigin, mainFrameOrigin));
</ins><span class="cx"> m_uniqueIDBDatabase->registerConnection(*this);
</span><span class="cx"> }
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceWebKit2DatabaseProcessIndexedDBDatabaseProcessIDBConnectionh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebKit2/DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.h (196734 => 196735)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit2/DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.h 2016-02-18 01:17:36 UTC (rev 196734)
+++ trunk/Source/WebKit2/DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.h 2016-02-18 01:25:21 UTC (rev 196735)
</span><span class="lines">@@ -31,7 +31,7 @@
</span><span class="cx"> #if ENABLE(INDEXED_DATABASE) && ENABLE(DATABASE_PROCESS)
</span><span class="cx">
</span><span class="cx"> #include "DatabaseProcessIDBConnectionMessages.h"
</span><del>-#include "UniqueIDBDatabaseIdentifier.h"
</del><ins>+#include "LegacyUniqueIDBDatabaseIdentifier.h"
</ins><span class="cx"> #include <WebCore/SecurityOriginData.h>
</span><span class="cx"> #include <wtf/text/WTFString.h>
</span><span class="cx">
</span><span class="lines">@@ -43,7 +43,7 @@
</span><span class="cx"> namespace WebKit {
</span><span class="cx">
</span><span class="cx"> class DatabaseToWebProcessConnection;
</span><del>-class UniqueIDBDatabase;
</del><ins>+class LegacyUniqueIDBDatabase;
</ins><span class="cx">
</span><span class="cx"> class DatabaseProcessIDBConnection : public RefCounted<DatabaseProcessIDBConnection>, public IPC::MessageSender {
</span><span class="cx"> public:
</span><span class="lines">@@ -99,7 +99,7 @@
</span><span class="cx"> Ref<DatabaseToWebProcessConnection> m_connection;
</span><span class="cx"> uint64_t m_serverConnectionIdentifier;
</span><span class="cx">
</span><del>- RefPtr<UniqueIDBDatabase> m_uniqueIDBDatabase;
</del><ins>+ RefPtr<LegacyUniqueIDBDatabase> m_uniqueIDBDatabase;
</ins><span class="cx"> };
</span><span class="cx">
</span><span class="cx"> } // namespace WebKit
</span></span></pre></div>
<a id="trunkSourceWebKit2DatabaseProcessIndexedDBLegacyUniqueIDBDatabasecppfromrev196734trunkSourceWebKit2DatabaseProcessIndexedDBUniqueIDBDatabasecpp"></a>
<div class="copfile"><h4>Copied: trunk/Source/WebKit2/DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabase.cpp (from rev 196734, trunk/Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabase.cpp) (0 => 196735)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit2/DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabase.cpp (rev 0)
+++ trunk/Source/WebKit2/DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabase.cpp 2016-02-18 01:25:21 UTC (rev 196735)
</span><span class="lines">@@ -0,0 +1,1203 @@
</span><ins>+/*
+ * Copyright (C) 2013 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. AND ITS CONTRIBUTORS ``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 ITS 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 "LegacyUniqueIDBDatabase.h"
+
+#if ENABLE(INDEXED_DATABASE) && ENABLE(DATABASE_PROCESS)
+
+#include "AsyncRequest.h"
+#include "DataReference.h"
+#include "DatabaseProcess.h"
+#include "DatabaseProcessIDBConnection.h"
+#include "Logging.h"
+#include "UniqueIDBDatabaseBackingStoreSQLite.h"
+#include "WebCrossThreadCopier.h"
+#include <WebCore/CrossThreadTask.h>
+#include <WebCore/FileSystem.h>
+#include <WebCore/IDBDatabaseMetadata.h>
+#include <WebCore/IDBGetResult.h>
+#include <WebCore/IDBKeyData.h>
+#include <WebCore/IDBKeyRangeData.h>
+#include <WebCore/SecurityOrigin.h>
+#include <wtf/MainThread.h>
+#include <wtf/text/WTFString.h>
+
+using namespace WebCore;
+
+namespace WebKit {
+
+String LegacyUniqueIDBDatabase::calculateAbsoluteDatabaseFilename(const String& absoluteDatabaseDirectory)
+{
+ return pathByAppendingComponent(absoluteDatabaseDirectory, "IndexedDB.sqlite3");
+}
+
+LegacyUniqueIDBDatabase::LegacyUniqueIDBDatabase(const LegacyUniqueIDBDatabaseIdentifier& identifier)
+ : m_identifier(identifier)
+ , m_acceptingNewRequests(true)
+ , m_didGetMetadataFromBackingStore(false)
+{
+ m_inMemory = !canShareDatabases(identifier.openingOrigin(), identifier.mainFrameOrigin());
+ if (m_inMemory)
+ return;
+
+ // *********
+ // IMPORTANT: Do not change the directory structure for indexed databases on disk without first consulting a reviewer from Apple (<rdar://problem/17454712>)
+ // *********
+
+ // Each unique Indexed Database exists in a directory named for the database, which exists in a directory representing its opening origin.
+ m_databaseRelativeDirectory = pathByAppendingComponent(databaseFilenameIdentifier(identifier.openingOrigin()), filenameForDatabaseName());
+
+ DatabaseProcess::singleton().ensureIndexedDatabaseRelativePathExists(m_databaseRelativeDirectory);
+}
+
+LegacyUniqueIDBDatabase::~LegacyUniqueIDBDatabase()
+{
+ ASSERT(!m_acceptingNewRequests);
+ ASSERT(m_pendingMetadataRequests.isEmpty());
+}
+
+String LegacyUniqueIDBDatabase::filenameForDatabaseName() const
+{
+ ASSERT(!m_identifier.databaseName().isNull());
+
+ if (m_identifier.databaseName().isEmpty())
+ return "%00";
+
+ String filename = encodeForFileName(m_identifier.databaseName());
+ filename.replace('.', "%2E");
+
+ return filename;
+}
+
+String LegacyUniqueIDBDatabase::databaseFilenameIdentifier(const SecurityOriginData& originData) const
+{
+ Ref<SecurityOrigin> securityOrigin(SecurityOrigin::create(originData.protocol, originData.host, originData.port));
+ return securityOrigin.get().databaseIdentifier();
+}
+
+bool LegacyUniqueIDBDatabase::canShareDatabases(const SecurityOriginData& openingOrigin, const SecurityOriginData& mainFrameOrigin) const
+{
+ // For now, an origin's database access is predicated on equality with the other origin.
+ // We might need to make this more nuanced later.
+ return openingOrigin == mainFrameOrigin;
+}
+
+void LegacyUniqueIDBDatabase::registerConnection(DatabaseProcessIDBConnection& connection)
+{
+ ASSERT(!m_connections.contains(&connection));
+ m_connections.add(&connection);
+}
+
+void LegacyUniqueIDBDatabase::unregisterConnection(DatabaseProcessIDBConnection& connection)
+{
+ ASSERT(m_connections.contains(&connection));
+ resetAllTransactions(connection);
+ m_connections.remove(&connection);
+
+ if (m_connections.isEmpty() && m_pendingTransactionRollbacks.isEmpty()) {
+ shutdown(LegacyUniqueIDBDatabaseShutdownType::NormalShutdown);
+ DatabaseProcess::singleton().removeLegacyUniqueIDBDatabase(*this);
+ }
+}
+
+void LegacyUniqueIDBDatabase::shutdown(LegacyUniqueIDBDatabaseShutdownType type)
+{
+ ASSERT(RunLoop::isMain());
+
+ if (!m_acceptingNewRequests)
+ return;
+
+ m_acceptingNewRequests = false;
+
+ // Balanced by an adoptRef in ::didShutdownBackingStore()
+ ref();
+
+ {
+ LockHolder locker(m_databaseTaskMutex);
+ m_databaseTasks.clear();
+ }
+
+ postDatabaseTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::shutdownBackingStore, type, absoluteDatabaseDirectory()), DatabaseTaskType::Shutdown);
+}
+
+void LegacyUniqueIDBDatabase::shutdownBackingStore(LegacyUniqueIDBDatabaseShutdownType type, const String& databaseDirectory)
+{
+ ASSERT(!RunLoop::isMain());
+
+ m_backingStore = nullptr;
+
+ if (type == LegacyUniqueIDBDatabaseShutdownType::DeleteShutdown) {
+ String dbFilename = LegacyUniqueIDBDatabase::calculateAbsoluteDatabaseFilename(databaseDirectory);
+ LOG(IDB, "LegacyUniqueIDBDatabase::shutdownBackingStore deleting file '%s' on disk", dbFilename.utf8().data());
+ deleteFile(dbFilename);
+ deleteEmptyDirectory(databaseDirectory);
+ }
+
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didShutdownBackingStore, type), DatabaseTaskType::Shutdown);
+}
+
+void LegacyUniqueIDBDatabase::didShutdownBackingStore(LegacyUniqueIDBDatabaseShutdownType type)
+{
+ ASSERT(RunLoop::isMain());
+
+ // Balanced by a ref in ::shutdown()
+ RefPtr<LegacyUniqueIDBDatabase> protector(adoptRef(this));
+
+ // Empty out remaining main thread tasks.
+ while (performNextMainThreadTask()) {
+ }
+
+ // No more requests will be handled, so abort all outstanding requests.
+ for (const auto& request : m_pendingMetadataRequests)
+ request->requestAborted();
+ for (const auto& request : m_pendingTransactionRequests.values())
+ request->requestAborted();
+ for (const auto& request : m_pendingDatabaseTasks.values())
+ request->requestAborted();
+
+ m_pendingMetadataRequests.clear();
+ m_pendingTransactionRequests.clear();
+ m_pendingDatabaseTasks.clear();
+
+ if (m_pendingShutdownTask)
+ m_pendingShutdownTask->completeRequest(type);
+
+ m_pendingShutdownTask = nullptr;
+}
+
+void LegacyUniqueIDBDatabase::deleteDatabase(std::function<void (bool)> successCallback)
+{
+ ASSERT(RunLoop::isMain());
+
+ if (!m_acceptingNewRequests) {
+ // Someone else has already shutdown this database, so we can't request a delete.
+ callOnMainThread([successCallback] {
+ successCallback(false);
+ });
+ return;
+ }
+
+ RefPtr<LegacyUniqueIDBDatabase> protector(this);
+ m_pendingShutdownTask = AsyncRequestImpl<LegacyUniqueIDBDatabaseShutdownType>::create([this, protector, successCallback](LegacyUniqueIDBDatabaseShutdownType type) {
+ // If the shutdown just completed was a Delete shutdown then we succeeded.
+ // If not report failure instead of trying again.
+ successCallback(type == LegacyUniqueIDBDatabaseShutdownType::DeleteShutdown);
+ }, [this, protector, successCallback] {
+ successCallback(false);
+ });
+
+ shutdown(LegacyUniqueIDBDatabaseShutdownType::DeleteShutdown);
+}
+
+void LegacyUniqueIDBDatabase::getOrEstablishIDBDatabaseMetadata(std::function<void (bool, const IDBDatabaseMetadata&)> completionCallback)
+{
+ ASSERT(RunLoop::isMain());
+
+ if (!m_acceptingNewRequests) {
+ completionCallback(false, IDBDatabaseMetadata());
+ return;
+ }
+
+ // If we've already retrieved metadata from the backing store, return it now.
+ if (m_didGetMetadataFromBackingStore) {
+ if (m_metadata)
+ completionCallback(true, *m_metadata);
+ else
+ completionCallback(false, IDBDatabaseMetadata());
+
+ return;
+ }
+
+ // If this is the first unanswered metadata request, then later we need to
+ // post a task to open the backing store and get metadata.
+ bool shouldOpenBackingStore = m_pendingMetadataRequests.isEmpty();
+
+ // Then remember this metadata request to be answered later.
+ RefPtr<AsyncRequest> request = AsyncRequestImpl<>::create([completionCallback, this] {
+ completionCallback(!!m_metadata, m_metadata ? *m_metadata : IDBDatabaseMetadata());
+ }, [completionCallback] {
+ // The boolean flag to the completion callback represents whether the
+ // attempt to get/establish metadata succeeded or failed.
+ // Since we're aborting the attempt, it failed, so we always pass in false.
+ completionCallback(false, IDBDatabaseMetadata());
+ });
+
+ m_pendingMetadataRequests.append(request.release());
+
+ if (shouldOpenBackingStore)
+ postDatabaseTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::openBackingStoreAndReadMetadata, m_identifier, absoluteDatabaseDirectory()));
+}
+
+void LegacyUniqueIDBDatabase::openBackingStoreAndReadMetadata(const LegacyUniqueIDBDatabaseIdentifier& identifier, const String& databaseDirectory)
+{
+ ASSERT(!RunLoop::isMain());
+ ASSERT(!m_backingStore);
+
+ if (m_inMemory) {
+ LOG_ERROR("Support for in-memory databases not yet implemented");
+ return;
+ }
+
+ m_backingStore = UniqueIDBDatabaseBackingStoreSQLite::create(identifier, databaseDirectory);
+ std::unique_ptr<IDBDatabaseMetadata> metadata = m_backingStore->getOrEstablishMetadata();
+
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didOpenBackingStoreAndReadMetadata, metadata ? *metadata : IDBDatabaseMetadata(), !!metadata));
+}
+
+void LegacyUniqueIDBDatabase::didOpenBackingStoreAndReadMetadata(const IDBDatabaseMetadata& metadata, bool success)
+{
+ ASSERT(RunLoop::isMain());
+ ASSERT(!m_metadata);
+
+ m_didGetMetadataFromBackingStore = true;
+
+ if (success)
+ m_metadata = std::make_unique<IDBDatabaseMetadata>(metadata);
+
+ while (!m_pendingMetadataRequests.isEmpty()) {
+ RefPtr<AsyncRequest> request = m_pendingMetadataRequests.takeFirst();
+ request->completeRequest();
+ }
+}
+
+void LegacyUniqueIDBDatabase::openTransaction(const IDBIdentifier& transactionIdentifier, const Vector<int64_t>& objectStoreIDs, IndexedDB::TransactionMode mode, std::function<void (bool)> successCallback)
+{
+ postTransactionOperation(transactionIdentifier, createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::openBackingStoreTransaction, transactionIdentifier, objectStoreIDs, mode), successCallback);
+}
+
+void LegacyUniqueIDBDatabase::beginTransaction(const IDBIdentifier& transactionIdentifier, std::function<void (bool)> successCallback)
+{
+ postTransactionOperation(transactionIdentifier, createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::beginBackingStoreTransaction, transactionIdentifier), successCallback);
+}
+
+void LegacyUniqueIDBDatabase::commitTransaction(const IDBIdentifier& transactionIdentifier, std::function<void (bool)> successCallback)
+{
+ postTransactionOperation(transactionIdentifier, createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::commitBackingStoreTransaction, transactionIdentifier), successCallback);
+}
+
+void LegacyUniqueIDBDatabase::resetTransaction(const IDBIdentifier& transactionIdentifier, std::function<void (bool)> successCallback)
+{
+ postTransactionOperation(transactionIdentifier, createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::resetBackingStoreTransaction, transactionIdentifier), successCallback);
+}
+
+void LegacyUniqueIDBDatabase::rollbackTransaction(const IDBIdentifier& transactionIdentifier, std::function<void (bool)> successCallback)
+{
+ postTransactionOperation(transactionIdentifier, createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::rollbackBackingStoreTransaction, transactionIdentifier), successCallback);
+}
+
+void LegacyUniqueIDBDatabase::postTransactionOperation(const IDBIdentifier& transactionIdentifier, std::unique_ptr<CrossThreadTask> task, std::function<void (bool)> successCallback)
+{
+ ASSERT(RunLoop::isMain());
+
+ if (!m_acceptingNewRequests) {
+ successCallback(false);
+ return;
+ }
+
+ if (m_pendingTransactionRequests.contains(transactionIdentifier)) {
+ LOG_ERROR("Attempting to queue an operation for a transaction that already has an operation pending. Each transaction should only have one operation pending at a time.");
+ successCallback(false);
+ return;
+ }
+
+ postDatabaseTask(WTFMove(task));
+
+ RefPtr<AsyncRequest> request = AsyncRequestImpl<bool>::create([successCallback](bool success) {
+ successCallback(success);
+ }, [successCallback] {
+ successCallback(false);
+ });
+
+ m_pendingTransactionRequests.add(transactionIdentifier, request.release());
+}
+
+void LegacyUniqueIDBDatabase::didCompleteTransactionOperation(const IDBIdentifier& transactionIdentifier, bool success)
+{
+ ASSERT(RunLoop::isMain());
+
+ RefPtr<AsyncRequest> request = m_pendingTransactionRequests.take(transactionIdentifier);
+
+ if (request)
+ request->completeRequest(success);
+
+ if (m_pendingTransactionRollbacks.contains(transactionIdentifier))
+ finalizeRollback(transactionIdentifier);
+}
+
+void LegacyUniqueIDBDatabase::changeDatabaseVersion(const IDBIdentifier& transactionIdentifier, uint64_t newVersion, std::function<void (bool)> successCallback)
+{
+ ASSERT(RunLoop::isMain());
+
+ if (!m_acceptingNewRequests) {
+ successCallback(false);
+ return;
+ }
+
+ uint64_t oldVersion = m_metadata->version;
+ m_metadata->version = newVersion;
+
+ RefPtr<AsyncRequest> request = AsyncRequestImpl<bool>::create([this, oldVersion, successCallback](bool success) {
+ if (!success)
+ m_metadata->version = oldVersion;
+ successCallback(success);
+ }, [this, oldVersion, successCallback] {
+ m_metadata->version = oldVersion;
+ successCallback(false);
+ });
+
+ uint64_t requestID = request->requestID();
+ m_pendingDatabaseTasks.add(requestID, request.release());
+
+ postDatabaseTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::changeDatabaseVersionInBackingStore, requestID, transactionIdentifier, newVersion));
+}
+
+void LegacyUniqueIDBDatabase::didChangeDatabaseVersion(uint64_t requestID, bool success)
+{
+ didCompleteBoolRequest(requestID, success);
+}
+
+void LegacyUniqueIDBDatabase::didCreateObjectStore(uint64_t requestID, bool success)
+{
+ didCompleteBoolRequest(requestID, success);
+}
+
+void LegacyUniqueIDBDatabase::didDeleteObjectStore(uint64_t requestID, bool success)
+{
+ didCompleteBoolRequest(requestID, success);
+}
+
+void LegacyUniqueIDBDatabase::didClearObjectStore(uint64_t requestID, bool success)
+{
+ didCompleteBoolRequest(requestID, success);
+}
+
+void LegacyUniqueIDBDatabase::didCreateIndex(uint64_t requestID, bool success)
+{
+ didCompleteBoolRequest(requestID, success);
+}
+
+void LegacyUniqueIDBDatabase::didDeleteIndex(uint64_t requestID, bool success)
+{
+ didCompleteBoolRequest(requestID, success);
+}
+
+void LegacyUniqueIDBDatabase::didCompleteBoolRequest(uint64_t requestID, bool success)
+{
+ m_pendingDatabaseTasks.take(requestID).get().completeRequest(success);
+}
+
+void LegacyUniqueIDBDatabase::createObjectStore(const IDBIdentifier& transactionIdentifier, const IDBObjectStoreMetadata& metadata, std::function<void (bool)> successCallback)
+{
+ ASSERT(RunLoop::isMain());
+
+ if (!m_acceptingNewRequests) {
+ successCallback(false);
+ return;
+ }
+
+ ASSERT(!m_metadata->objectStores.contains(metadata.id));
+ m_metadata->objectStores.set(metadata.id, metadata);
+ int64_t addedObjectStoreID = metadata.id;
+
+ RefPtr<AsyncRequest> request = AsyncRequestImpl<bool>::create([this, addedObjectStoreID, successCallback](bool success) {
+ if (!success)
+ m_metadata->objectStores.remove(addedObjectStoreID);
+ successCallback(success);
+ }, [this, addedObjectStoreID, successCallback] {
+ m_metadata->objectStores.remove(addedObjectStoreID);
+ successCallback(false);
+ });
+
+ uint64_t requestID = request->requestID();
+ m_pendingDatabaseTasks.add(requestID, request.release());
+
+ postDatabaseTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::createObjectStoreInBackingStore, requestID, transactionIdentifier, metadata));
+}
+
+void LegacyUniqueIDBDatabase::deleteObjectStore(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, std::function<void (bool)> successCallback)
+{
+ ASSERT(RunLoop::isMain());
+
+ if (!m_acceptingNewRequests) {
+ successCallback(false);
+ return;
+ }
+
+ ASSERT(m_metadata->objectStores.contains(objectStoreID));
+ IDBObjectStoreMetadata metadata = m_metadata->objectStores.take(objectStoreID);
+
+ RefPtr<AsyncRequest> request = AsyncRequestImpl<bool>::create([this, metadata, successCallback](bool success) {
+ if (!success)
+ m_metadata->objectStores.set(metadata.id, metadata);
+ successCallback(success);
+ }, [this, metadata, successCallback] {
+ m_metadata->objectStores.set(metadata.id, metadata);
+ successCallback(false);
+ });
+
+ uint64_t requestID = request->requestID();
+ m_pendingDatabaseTasks.add(requestID, request.release());
+
+ postDatabaseTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::deleteObjectStoreInBackingStore, requestID, transactionIdentifier, objectStoreID));
+}
+
+void LegacyUniqueIDBDatabase::clearObjectStore(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, std::function<void (bool)> successCallback)
+{
+ ASSERT(RunLoop::isMain());
+
+ if (!m_acceptingNewRequests) {
+ successCallback(false);
+ return;
+ }
+
+ ASSERT(m_metadata->objectStores.contains(objectStoreID));
+
+ RefPtr<AsyncRequest> request = AsyncRequestImpl<bool>::create([this, successCallback](bool success) {
+ successCallback(success);
+ }, [this, successCallback] {
+ successCallback(false);
+ });
+
+ uint64_t requestID = request->requestID();
+ m_pendingDatabaseTasks.add(requestID, request.release());
+
+ postDatabaseTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::clearObjectStoreInBackingStore, requestID, transactionIdentifier, objectStoreID));
+}
+
+void LegacyUniqueIDBDatabase::createIndex(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const IDBIndexMetadata& metadata, std::function<void (bool)> successCallback)
+{
+ ASSERT(RunLoop::isMain());
+
+ if (!m_acceptingNewRequests) {
+ successCallback(false);
+ return;
+ }
+
+ ASSERT(m_metadata->objectStores.contains(objectStoreID));
+ ASSERT(!m_metadata->objectStores.get(objectStoreID).indexes.contains(metadata.id));
+ m_metadata->objectStores.get(objectStoreID).indexes.set(metadata.id, metadata);
+ int64_t addedIndexID = metadata.id;
+
+ RefPtr<AsyncRequest> request = AsyncRequestImpl<bool>::create([this, objectStoreID, addedIndexID, successCallback](bool success) {
+ if (!success) {
+ auto objectStoreFind = m_metadata->objectStores.find(objectStoreID);
+ if (objectStoreFind != m_metadata->objectStores.end())
+ objectStoreFind->value.indexes.remove(addedIndexID);
+ }
+ successCallback(success);
+ }, [this, objectStoreID, addedIndexID, successCallback] {
+ auto objectStoreFind = m_metadata->objectStores.find(objectStoreID);
+ if (objectStoreFind != m_metadata->objectStores.end())
+ objectStoreFind->value.indexes.remove(addedIndexID);
+ successCallback(false);
+ });
+
+ uint64_t requestID = request->requestID();
+ m_pendingDatabaseTasks.add(requestID, request.release());
+
+ postDatabaseTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::createIndexInBackingStore, requestID, transactionIdentifier, objectStoreID, metadata));
+}
+
+void LegacyUniqueIDBDatabase::deleteIndex(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, std::function<void (bool)> successCallback)
+{
+ ASSERT(RunLoop::isMain());
+
+ if (!m_acceptingNewRequests) {
+ successCallback(false);
+ return;
+ }
+
+ ASSERT(m_metadata->objectStores.contains(objectStoreID));
+ ASSERT(m_metadata->objectStores.get(objectStoreID).indexes.contains(indexID));
+
+ IDBIndexMetadata metadata = m_metadata->objectStores.get(objectStoreID).indexes.take(indexID);
+
+ RefPtr<AsyncRequest> request = AsyncRequestImpl<bool>::create([this, objectStoreID, metadata, successCallback](bool success) {
+ if (!success) {
+ auto objectStoreFind = m_metadata->objectStores.find(objectStoreID);
+ if (objectStoreFind != m_metadata->objectStores.end())
+ objectStoreFind->value.indexes.set(metadata.id, metadata);
+ }
+ successCallback(success);
+ }, [this, objectStoreID, metadata, successCallback] {
+ auto objectStoreFind = m_metadata->objectStores.find(objectStoreID);
+ if (objectStoreFind != m_metadata->objectStores.end())
+ objectStoreFind->value.indexes.set(metadata.id, metadata);
+ successCallback(false);
+ });
+
+ uint64_t requestID = request->requestID();
+ m_pendingDatabaseTasks.add(requestID, request.release());
+
+ postDatabaseTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::deleteIndexInBackingStore, requestID, transactionIdentifier, objectStoreID, indexID));
+}
+
+void LegacyUniqueIDBDatabase::putRecord(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const IDBKeyData& keyData, const IPC::DataReference& value, int64_t putMode, const Vector<int64_t>& indexIDs, const Vector<Vector<IDBKeyData>>& indexKeys, std::function<void (const IDBKeyData&, uint32_t, const String&)> callback)
+{
+ ASSERT(RunLoop::isMain());
+
+ if (!m_acceptingNewRequests) {
+ callback(IDBKeyData(), INVALID_STATE_ERR, "Unable to put record into database because it has shut down");
+ return;
+ }
+
+ ASSERT(m_metadata->objectStores.contains(objectStoreID));
+
+ RefPtr<AsyncRequest> request = AsyncRequestImpl<IDBKeyData, uint32_t, String>::create([this, callback](const IDBKeyData& keyData, uint32_t errorCode, const String& errorMessage) {
+ callback(keyData, errorCode, errorMessage);
+ }, [this, callback] {
+ callback(IDBKeyData(), INVALID_STATE_ERR, "Unable to put record into database");
+ });
+
+ uint64_t requestID = request->requestID();
+ m_pendingDatabaseTasks.add(requestID, request.release());
+
+ postDatabaseTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::putRecordInBackingStore, requestID, transactionIdentifier, m_metadata->objectStores.get(objectStoreID), keyData, value.vector(), putMode, indexIDs, indexKeys));
+}
+
+void LegacyUniqueIDBDatabase::getRecord(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, const IDBKeyRangeData& keyRangeData, IndexedDB::CursorType cursorType, std::function<void (const IDBGetResult&, uint32_t, const String&)> callback)
+{
+ ASSERT(RunLoop::isMain());
+
+ if (!m_acceptingNewRequests) {
+ callback(IDBGetResult(), INVALID_STATE_ERR, "Unable to get record from database because it has shut down");
+ return;
+ }
+
+ ASSERT(m_metadata->objectStores.contains(objectStoreID));
+
+ RefPtr<AsyncRequest> request = AsyncRequestImpl<IDBGetResult, uint32_t, String>::create([this, callback](const IDBGetResult& result, uint32_t errorCode, const String& errorMessage) {
+ callback(result, errorCode, errorMessage);
+ }, [this, callback] {
+ callback(IDBGetResult(), INVALID_STATE_ERR, "Unable to get record from database");
+ });
+
+ uint64_t requestID = request->requestID();
+ m_pendingDatabaseTasks.add(requestID, request.release());
+
+ postDatabaseTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::getRecordFromBackingStore, requestID, transactionIdentifier, m_metadata->objectStores.get(objectStoreID), indexID, keyRangeData, cursorType));
+}
+
+void LegacyUniqueIDBDatabase::openCursor(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, IndexedDB::CursorDirection cursorDirection, IndexedDB::CursorType cursorType, IDBDatabaseBackend::TaskType taskType, const IDBKeyRangeData& keyRangeData, std::function<void (int64_t, const IDBKeyData&, const IDBKeyData&, PassRefPtr<SharedBuffer>, uint32_t, const String&)> callback)
+{
+ ASSERT(RunLoop::isMain());
+
+ if (!m_acceptingNewRequests) {
+ callback(0, nullptr, nullptr, nullptr, INVALID_STATE_ERR, "Unable to open cursor in database because it has shut down");
+ return;
+ }
+
+ ASSERT(m_metadata->objectStores.contains(objectStoreID));
+
+ RefPtr<AsyncRequest> request = AsyncRequestImpl<int64_t, IDBKeyData, IDBKeyData, PassRefPtr<SharedBuffer>, uint32_t, String>::create([this, callback](int64_t cursorID, const IDBKeyData& key, const IDBKeyData& primaryKey, PassRefPtr<SharedBuffer> value, uint32_t errorCode, const String& errorMessage) {
+ callback(cursorID, key, primaryKey, value, errorCode, errorMessage);
+ }, [this, callback] {
+ callback(0, nullptr, nullptr, nullptr, INVALID_STATE_ERR, "Unable to get record from database");
+ });
+
+ uint64_t requestID = request->requestID();
+ m_pendingDatabaseTasks.add(requestID, request.release());
+
+ postDatabaseTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::openCursorInBackingStore, requestID, transactionIdentifier, objectStoreID, indexID, cursorDirection, cursorType, taskType, keyRangeData));
+}
+
+void LegacyUniqueIDBDatabase::cursorAdvance(const IDBIdentifier& cursorIdentifier, uint64_t count, std::function<void (const IDBKeyData&, const IDBKeyData&, PassRefPtr<SharedBuffer>, uint32_t, const String&)> callback)
+{
+ ASSERT(RunLoop::isMain());
+
+ if (!m_acceptingNewRequests) {
+ callback(nullptr, nullptr, nullptr, INVALID_STATE_ERR, "Unable to advance cursor in database because it has shut down");
+ return;
+ }
+
+ RefPtr<AsyncRequest> request = AsyncRequestImpl<IDBKeyData, IDBKeyData, PassRefPtr<SharedBuffer>, uint32_t, String>::create([this, callback](const IDBKeyData& key, const IDBKeyData& primaryKey, PassRefPtr<SharedBuffer> value, uint32_t errorCode, const String& errorMessage) {
+ callback(key, primaryKey, value, errorCode, errorMessage);
+ }, [this, callback] {
+ callback(nullptr, nullptr, nullptr, INVALID_STATE_ERR, "Unable to advance cursor in database");
+ });
+
+ uint64_t requestID = request->requestID();
+ m_pendingDatabaseTasks.add(requestID, request.release());
+
+ postDatabaseTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::advanceCursorInBackingStore, requestID, cursorIdentifier, count));
+}
+
+void LegacyUniqueIDBDatabase::cursorIterate(const IDBIdentifier& cursorIdentifier, const IDBKeyData& key, std::function<void (const IDBKeyData&, const IDBKeyData&, PassRefPtr<SharedBuffer>, uint32_t, const String&)> callback)
+{
+ ASSERT(RunLoop::isMain());
+
+ if (!m_acceptingNewRequests) {
+ callback(nullptr, nullptr, nullptr, INVALID_STATE_ERR, "Unable to iterate cursor in database because it has shut down");
+ return;
+ }
+
+ RefPtr<AsyncRequest> request = AsyncRequestImpl<IDBKeyData, IDBKeyData, PassRefPtr<SharedBuffer>, uint32_t, String>::create([this, callback](const IDBKeyData& key, const IDBKeyData& primaryKey, PassRefPtr<SharedBuffer> value, uint32_t errorCode, const String& errorMessage) {
+ callback(key, primaryKey, value, errorCode, errorMessage);
+ }, [this, callback] {
+ callback(nullptr, nullptr, nullptr, INVALID_STATE_ERR, "Unable to iterate cursor in database");
+ });
+
+ uint64_t requestID = request->requestID();
+ m_pendingDatabaseTasks.add(requestID, request.release());
+
+ postDatabaseTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::iterateCursorInBackingStore, requestID, cursorIdentifier, key));
+}
+
+void LegacyUniqueIDBDatabase::count(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, const IDBKeyRangeData& keyRangeData, std::function<void (int64_t, uint32_t, const String&)> callback)
+{
+ ASSERT(RunLoop::isMain());
+
+ if (!m_acceptingNewRequests) {
+ callback(0, INVALID_STATE_ERR, "Unable to get count from database because it has shut down");
+ return;
+ }
+
+ RefPtr<AsyncRequest> request = AsyncRequestImpl<int64_t, uint32_t, String>::create([this, callback](int64_t count, uint32_t errorCode, const String& errorMessage) {
+ callback(count, errorCode, errorMessage);
+ }, [this, callback] {
+ callback(0, INVALID_STATE_ERR, "Unable to get count from database");
+ });
+
+ uint64_t requestID = request->requestID();
+ m_pendingDatabaseTasks.add(requestID, request.release());
+
+ postDatabaseTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::countInBackingStore, requestID, transactionIdentifier, objectStoreID, indexID, keyRangeData));
+}
+
+void LegacyUniqueIDBDatabase::deleteRange(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const IDBKeyRangeData& keyRangeData, std::function<void (uint32_t, const String&)> callback)
+{
+ ASSERT(RunLoop::isMain());
+
+ if (!m_acceptingNewRequests) {
+ callback(INVALID_STATE_ERR, "Unable to deleteRange from database because it has shut down");
+ return;
+ }
+
+ RefPtr<AsyncRequest> request = AsyncRequestImpl<uint32_t, String>::create([callback](uint32_t errorCode, const String& errorMessage) {
+ callback(errorCode, errorMessage);
+ }, [callback] {
+ callback(INVALID_STATE_ERR, "Unable to deleteRange from database");
+ });
+
+ uint64_t requestID = request->requestID();
+ m_pendingDatabaseTasks.add(requestID, request.release());
+
+ postDatabaseTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::deleteRangeInBackingStore, requestID, transactionIdentifier, objectStoreID, keyRangeData));
+}
+
+void LegacyUniqueIDBDatabase::openBackingStoreTransaction(const IDBIdentifier& transactionIdentifier, const Vector<int64_t>& objectStoreIDs, IndexedDB::TransactionMode mode)
+{
+ ASSERT(!RunLoop::isMain());
+ ASSERT(m_backingStore);
+
+ bool success = m_backingStore->establishTransaction(transactionIdentifier, objectStoreIDs, mode);
+
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didEstablishTransaction, transactionIdentifier, success));
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didCompleteTransactionOperation, transactionIdentifier, success));
+}
+
+void LegacyUniqueIDBDatabase::beginBackingStoreTransaction(const IDBIdentifier& transactionIdentifier)
+{
+ ASSERT(!RunLoop::isMain());
+ ASSERT(m_backingStore);
+
+ bool success = m_backingStore->beginTransaction(transactionIdentifier);
+
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didCompleteTransactionOperation, transactionIdentifier, success));
+}
+
+void LegacyUniqueIDBDatabase::commitBackingStoreTransaction(const IDBIdentifier& transactionIdentifier)
+{
+ ASSERT(!RunLoop::isMain());
+ ASSERT(m_backingStore);
+
+ bool success = m_backingStore->commitTransaction(transactionIdentifier);
+
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didCompleteTransactionOperation, transactionIdentifier, success));
+}
+
+void LegacyUniqueIDBDatabase::resetBackingStoreTransaction(const IDBIdentifier& transactionIdentifier)
+{
+ ASSERT(!RunLoop::isMain());
+ ASSERT(m_backingStore);
+
+ bool success = m_backingStore->resetTransaction(transactionIdentifier);
+
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didResetTransaction, transactionIdentifier, success));
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didCompleteTransactionOperation, transactionIdentifier, success));
+}
+
+void LegacyUniqueIDBDatabase::rollbackBackingStoreTransaction(const IDBIdentifier& transactionIdentifier)
+{
+ ASSERT(!RunLoop::isMain());
+ ASSERT(m_backingStore);
+
+ bool success = m_backingStore->rollbackTransaction(transactionIdentifier);
+
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didCompleteTransactionOperation, transactionIdentifier, success));
+}
+
+void LegacyUniqueIDBDatabase::changeDatabaseVersionInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, uint64_t newVersion)
+{
+ ASSERT(!RunLoop::isMain());
+ ASSERT(m_backingStore);
+
+ bool success = m_backingStore->changeDatabaseVersion(transactionIdentifier, newVersion);
+
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didChangeDatabaseVersion, requestID, success));
+}
+
+void LegacyUniqueIDBDatabase::createObjectStoreInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, const IDBObjectStoreMetadata& metadata)
+{
+ ASSERT(!RunLoop::isMain());
+ ASSERT(m_backingStore);
+
+ bool success = m_backingStore->createObjectStore(transactionIdentifier, metadata);
+
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didCreateObjectStore, requestID, success));
+}
+
+void LegacyUniqueIDBDatabase::deleteObjectStoreInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID)
+{
+ ASSERT(!RunLoop::isMain());
+ ASSERT(m_backingStore);
+
+ bool success = m_backingStore->deleteObjectStore(transactionIdentifier, objectStoreID);
+
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didDeleteObjectStore, requestID, success));
+}
+
+void LegacyUniqueIDBDatabase::clearObjectStoreInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID)
+{
+ ASSERT(!RunLoop::isMain());
+ ASSERT(m_backingStore);
+
+ bool success = m_backingStore->clearObjectStore(transactionIdentifier, objectStoreID);
+
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didClearObjectStore, requestID, success));
+}
+
+void LegacyUniqueIDBDatabase::createIndexInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const IDBIndexMetadata& metadata)
+{
+ ASSERT(!RunLoop::isMain());
+ ASSERT(m_backingStore);
+
+ bool success = m_backingStore->createIndex(transactionIdentifier, objectStoreID, metadata);
+
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didCreateIndex, requestID, success));
+}
+
+void LegacyUniqueIDBDatabase::deleteIndexInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID)
+{
+ ASSERT(!RunLoop::isMain());
+ ASSERT(m_backingStore);
+
+ bool success = m_backingStore->deleteIndex(transactionIdentifier, objectStoreID, indexID);
+
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didDeleteIndex, requestID, success));
+}
+
+void LegacyUniqueIDBDatabase::putRecordInBackingStore(uint64_t requestID, const IDBIdentifier& transaction, const IDBObjectStoreMetadata& objectStoreMetadata, const IDBKeyData& inputKeyData, const Vector<uint8_t>& value, int64_t putMode, const Vector<int64_t>& indexIDs, const Vector<Vector<IDBKeyData>>& indexKeys)
+{
+ ASSERT(!RunLoop::isMain());
+ ASSERT(m_backingStore);
+
+ bool keyWasGenerated = false;
+ IDBKeyData key;
+ int64_t keyNumber = 0;
+
+ if (putMode != IDBDatabaseBackend::CursorUpdate && objectStoreMetadata.autoIncrement && inputKeyData.isNull()) {
+ if (!m_backingStore->generateKeyNumber(transaction, objectStoreMetadata.id, keyNumber)) {
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didPutRecordInBackingStore, requestID, IDBKeyData(), IDBDatabaseException::UnknownError, ASCIILiteral("Internal backing store error checking for key existence")));
+ return;
+ }
+ key.setNumberValue(keyNumber);
+ keyWasGenerated = true;
+ } else
+ key = inputKeyData;
+
+ if (putMode == IDBDatabaseBackend::AddOnly) {
+ bool keyExists;
+ if (!m_backingStore->keyExistsInObjectStore(transaction, objectStoreMetadata.id, key, keyExists)) {
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didPutRecordInBackingStore, requestID, IDBKeyData(), IDBDatabaseException::UnknownError, ASCIILiteral("Internal backing store error checking for key existence")));
+ return;
+ }
+ if (keyExists) {
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didPutRecordInBackingStore, requestID, IDBKeyData(), IDBDatabaseException::ConstraintError, ASCIILiteral("Key already exists in the object store")));
+ return;
+ }
+ }
+
+ // The spec says that even if we're about to overwrite the record, perform the steps to delete it first.
+ // This is important because formally deleting it from from the object store also removes it from the appropriate indexes.
+ if (!m_backingStore->deleteRecord(transaction, objectStoreMetadata.id, key)) {
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didPutRecordInBackingStore, requestID, IDBKeyData(), IDBDatabaseException::UnknownError, ASCIILiteral("Replacing an existing key in backing store, unable to delete previous record.")));
+ return;
+ }
+
+ if (!m_backingStore->putRecord(transaction, objectStoreMetadata.id, key, value.data(), value.size())) {
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didPutRecordInBackingStore, requestID, IDBKeyData(), IDBDatabaseException::UnknownError, ASCIILiteral("Internal backing store error putting a record")));
+ return;
+ }
+
+ ASSERT(indexIDs.size() == indexKeys.size());
+ for (size_t i = 0; i < indexIDs.size(); ++i) {
+ for (size_t j = 0; j < indexKeys[i].size(); ++j) {
+ if (!m_backingStore->putIndexRecord(transaction, objectStoreMetadata.id, indexIDs[i], key, indexKeys[i][j])) {
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didPutRecordInBackingStore, requestID, IDBKeyData(), IDBDatabaseException::UnknownError, ASCIILiteral("Internal backing store error writing index key")));
+ return;
+ }
+ }
+ }
+
+ m_backingStore->notifyCursorsOfChanges(transaction, objectStoreMetadata.id);
+
+ if (putMode != IDBDatabaseBackend::CursorUpdate && objectStoreMetadata.autoIncrement && key.type() == KeyType::Number) {
+ if (!m_backingStore->updateKeyGeneratorNumber(transaction, objectStoreMetadata.id, keyNumber, keyWasGenerated)) {
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didPutRecordInBackingStore, requestID, IDBKeyData(), IDBDatabaseException::UnknownError, ASCIILiteral("Internal backing store error updating key generator")));
+ return;
+ }
+ }
+
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didPutRecordInBackingStore, requestID, key, 0, String(StringImpl::empty())));
+}
+
+void LegacyUniqueIDBDatabase::didPutRecordInBackingStore(uint64_t requestID, const IDBKeyData& keyData, uint32_t errorCode, const String& errorMessage)
+{
+ m_pendingDatabaseTasks.take(requestID).get().completeRequest(keyData, errorCode, errorMessage);
+}
+
+void LegacyUniqueIDBDatabase::getRecordFromBackingStore(uint64_t requestID, const IDBIdentifier& transaction, const IDBObjectStoreMetadata& objectStoreMetadata, int64_t indexID, const IDBKeyRangeData& keyRangeData, IndexedDB::CursorType cursorType)
+{
+ ASSERT(!RunLoop::isMain());
+ ASSERT(m_backingStore);
+
+ RefPtr<IDBKeyRange> keyRange = keyRangeData.maybeCreateIDBKeyRange();
+ ASSERT(keyRange);
+ if (!keyRange) {
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didGetRecordFromBackingStore, requestID, IDBGetResult(), IDBDatabaseException::UnknownError, ASCIILiteral("Invalid IDBKeyRange requested from backing store")));
+ return;
+ }
+
+ if (indexID == IDBIndexMetadata::InvalidId) {
+ // IDBObjectStore get record
+ RefPtr<SharedBuffer> result;
+
+ if (keyRange->isOnlyKey()) {
+ if (!m_backingStore->getKeyRecordFromObjectStore(transaction, objectStoreMetadata.id, *keyRange->lower(), result))
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didGetRecordFromBackingStore, requestID, IDBGetResult(), IDBDatabaseException::UnknownError, ASCIILiteral("Failed to get key record from object store in backing store")));
+ else {
+ IDBGetResult getResult = result ? IDBGetResult(result.release(), keyRange->lower(), objectStoreMetadata.keyPath) : IDBGetResult();
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didGetRecordFromBackingStore, requestID, getResult, 0, String(StringImpl::empty())));
+ }
+
+ return;
+ }
+
+ RefPtr<IDBKey> resultKey;
+
+ if (!m_backingStore->getKeyRangeRecordFromObjectStore(transaction, objectStoreMetadata.id, *keyRange, result, resultKey))
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didGetRecordFromBackingStore, requestID, IDBGetResult(), IDBDatabaseException::UnknownError, ASCIILiteral("Failed to get key range record from object store in backing store")));
+ else {
+ IDBGetResult getResult = result ? IDBGetResult(result.release(), resultKey.release(), objectStoreMetadata.keyPath) : IDBGetResult();
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didGetRecordFromBackingStore, requestID, getResult, 0, String(StringImpl::empty())));
+ }
+
+ return;
+ }
+
+ // IDBIndex get record
+
+ IDBGetResult result;
+ if (!m_backingStore->getIndexRecord(transaction, objectStoreMetadata.id, indexID, keyRangeData, cursorType, result)) {
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didGetRecordFromBackingStore, requestID, IDBGetResult(), IDBDatabaseException::UnknownError, ASCIILiteral("Failed to get index record from backing store")));
+ return;
+ }
+
+ // We must return a key path to know how to inject the result key into the result value object.
+ result.setKeyPath(objectStoreMetadata.keyPath);
+
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didGetRecordFromBackingStore, requestID, result, 0, String(StringImpl::empty())));
+}
+
+void LegacyUniqueIDBDatabase::didGetRecordFromBackingStore(uint64_t requestID, const IDBGetResult& result, uint32_t errorCode, const String& errorMessage)
+{
+ m_pendingDatabaseTasks.take(requestID).get().completeRequest(result, errorCode, errorMessage);
+}
+
+void LegacyUniqueIDBDatabase::openCursorInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, IndexedDB::CursorDirection cursorDirection, IndexedDB::CursorType cursorType, IDBDatabaseBackend::TaskType taskType, const IDBKeyRangeData& keyRange)
+{
+ ASSERT(!RunLoop::isMain());
+ ASSERT(m_backingStore);
+
+ int64_t cursorID = 0;
+ IDBKeyData key;
+ IDBKeyData primaryKey;
+ Vector<uint8_t> valueBuffer;
+ int32_t errorCode = 0;
+ String errorMessage;
+ bool success = m_backingStore->openCursor(transactionIdentifier, objectStoreID, indexID, cursorDirection, cursorType, taskType, keyRange, cursorID, key, primaryKey, valueBuffer);
+
+ if (!success) {
+ errorCode = IDBDatabaseException::UnknownError;
+ errorMessage = ASCIILiteral("Unknown error opening cursor in backing store");
+ }
+
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didOpenCursorInBackingStore, requestID, cursorID, key, primaryKey, valueBuffer, errorCode, errorMessage));
+}
+
+void LegacyUniqueIDBDatabase::didOpenCursorInBackingStore(uint64_t requestID, int64_t cursorID, const IDBKeyData& key, const IDBKeyData& primaryKey, const Vector<uint8_t>& valueBuffer, uint32_t errorCode, const String& errorMessage)
+{
+ m_pendingDatabaseTasks.take(requestID).get().completeRequest(cursorID, key, primaryKey, SharedBuffer::create(valueBuffer.data(), valueBuffer.size()), errorCode, errorMessage);
+}
+
+void LegacyUniqueIDBDatabase::advanceCursorInBackingStore(uint64_t requestID, const IDBIdentifier& cursorIdentifier, uint64_t count)
+{
+ IDBKeyData key;
+ IDBKeyData primaryKey;
+ Vector<uint8_t> valueBuffer;
+ int32_t errorCode = 0;
+ String errorMessage;
+ bool success = m_backingStore->advanceCursor(cursorIdentifier, count, key, primaryKey, valueBuffer);
+
+ if (!success) {
+ errorCode = IDBDatabaseException::UnknownError;
+ errorMessage = ASCIILiteral("Unknown error advancing cursor in backing store");
+ }
+
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didAdvanceCursorInBackingStore, requestID, key, primaryKey, valueBuffer, errorCode, errorMessage));
+}
+
+void LegacyUniqueIDBDatabase::didAdvanceCursorInBackingStore(uint64_t requestID, const IDBKeyData& key, const IDBKeyData& primaryKey, const Vector<uint8_t>& valueBuffer, uint32_t errorCode, const String& errorMessage)
+{
+ m_pendingDatabaseTasks.take(requestID).get().completeRequest(key, primaryKey, SharedBuffer::create(valueBuffer.data(), valueBuffer.size()), errorCode, errorMessage);
+}
+
+void LegacyUniqueIDBDatabase::iterateCursorInBackingStore(uint64_t requestID, const IDBIdentifier& cursorIdentifier, const IDBKeyData& iterateKey)
+{
+ IDBKeyData key;
+ IDBKeyData primaryKey;
+ Vector<uint8_t> valueBuffer;
+ int32_t errorCode = 0;
+ String errorMessage;
+ bool success = m_backingStore->iterateCursor(cursorIdentifier, iterateKey, key, primaryKey, valueBuffer);
+
+ if (!success) {
+ errorCode = IDBDatabaseException::UnknownError;
+ errorMessage = ASCIILiteral("Unknown error iterating cursor in backing store");
+ }
+
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didIterateCursorInBackingStore, requestID, key, primaryKey, valueBuffer, errorCode, errorMessage));
+}
+
+void LegacyUniqueIDBDatabase::didIterateCursorInBackingStore(uint64_t requestID, const IDBKeyData& key, const IDBKeyData& primaryKey, const Vector<uint8_t>& valueBuffer, uint32_t errorCode, const String& errorMessage)
+{
+ m_pendingDatabaseTasks.take(requestID).get().completeRequest(key, primaryKey, SharedBuffer::create(valueBuffer.data(), valueBuffer.size()), errorCode, errorMessage);
+}
+
+void LegacyUniqueIDBDatabase::countInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, const IDBKeyRangeData& keyRangeData)
+{
+ int64_t count;
+
+ if (!m_backingStore->count(transactionIdentifier, objectStoreID, indexID, keyRangeData, count)) {
+ LOG_ERROR("Failed to get count from backing store.");
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didCountInBackingStore, requestID, 0, IDBDatabaseException::UnknownError, ASCIILiteral("Failed to get count from backing store")));
+
+ return;
+ }
+
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didCountInBackingStore, requestID, count, 0, String(StringImpl::empty())));
+}
+
+void LegacyUniqueIDBDatabase::didCountInBackingStore(uint64_t requestID, int64_t count, uint32_t errorCode, const String& errorMessage)
+{
+ m_pendingDatabaseTasks.take(requestID).get().completeRequest(count, errorCode, errorMessage);
+}
+
+void LegacyUniqueIDBDatabase::deleteRangeInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const IDBKeyRangeData& keyRangeData)
+{
+ if (!m_backingStore->deleteRange(transactionIdentifier, objectStoreID, keyRangeData)) {
+ LOG_ERROR("Failed to delete range from backing store.");
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didDeleteRangeInBackingStore, requestID, IDBDatabaseException::UnknownError, ASCIILiteral("Failed to get count from backing store")));
+
+ return;
+ }
+
+ m_backingStore->notifyCursorsOfChanges(transactionIdentifier, objectStoreID);
+
+ postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didDeleteRangeInBackingStore, requestID, 0, String(StringImpl::empty())));
+}
+
+void LegacyUniqueIDBDatabase::didDeleteRangeInBackingStore(uint64_t requestID, uint32_t errorCode, const String& errorMessage)
+{
+ m_pendingDatabaseTasks.take(requestID).get().completeRequest(errorCode, errorMessage);
+}
+
+void LegacyUniqueIDBDatabase::didEstablishTransaction(const IDBIdentifier& transactionIdentifier, bool success)
+{
+ ASSERT(RunLoop::isMain());
+ if (!success)
+ return;
+
+ auto transactions = m_establishedTransactions.add(&transactionIdentifier.connection(), HashSet<IDBIdentifier>());
+ transactions.iterator->value.add(transactionIdentifier);
+}
+
+void LegacyUniqueIDBDatabase::didResetTransaction(const IDBIdentifier& transactionIdentifier, bool success)
+{
+ ASSERT(RunLoop::isMain());
+ if (!success)
+ return;
+
+ auto transactions = m_establishedTransactions.find(&transactionIdentifier.connection());
+ if (transactions != m_establishedTransactions.end())
+ transactions.get()->value.remove(transactionIdentifier);
+}
+
+void LegacyUniqueIDBDatabase::resetAllTransactions(const DatabaseProcessIDBConnection& connection)
+{
+ ASSERT(RunLoop::isMain());
+ auto transactions = m_establishedTransactions.find(&connection);
+ if (transactions == m_establishedTransactions.end() || !m_acceptingNewRequests)
+ return;
+
+ for (auto& transactionIdentifier : transactions.get()->value) {
+ m_pendingTransactionRollbacks.add(transactionIdentifier);
+ if (!m_pendingTransactionRequests.contains(transactionIdentifier))
+ finalizeRollback(transactionIdentifier);
+ }
+}
+
+void LegacyUniqueIDBDatabase::finalizeRollback(const WebKit::IDBIdentifier& transactionId)
+{
+ ASSERT(RunLoop::isMain());
+ ASSERT(m_pendingTransactionRollbacks.contains(transactionId));
+ ASSERT(!m_pendingTransactionRequests.contains(transactionId));
+ rollbackTransaction(transactionId, [this, transactionId](bool) {
+ ASSERT(RunLoop::isMain());
+ if (m_pendingTransactionRequests.contains(transactionId))
+ return;
+
+ ASSERT(m_pendingTransactionRollbacks.contains(transactionId));
+ m_pendingTransactionRollbacks.remove(transactionId);
+ resetTransaction(transactionId, [this, transactionId](bool) {
+ if (m_acceptingNewRequests && m_connections.isEmpty() && m_pendingTransactionRollbacks.isEmpty()) {
+ shutdown(LegacyUniqueIDBDatabaseShutdownType::NormalShutdown);
+ DatabaseProcess::singleton().removeLegacyUniqueIDBDatabase(*this);
+ }
+ });
+ });
+}
+
+String LegacyUniqueIDBDatabase::absoluteDatabaseDirectory() const
+{
+ ASSERT(RunLoop::isMain());
+ return DatabaseProcess::singleton().absoluteIndexedDatabasePathFromDatabaseRelativePath(m_databaseRelativeDirectory);
+}
+
+void LegacyUniqueIDBDatabase::postMainThreadTask(std::unique_ptr<CrossThreadTask> task, DatabaseTaskType taskType)
+{
+ ASSERT(!RunLoop::isMain());
+
+ if (!m_acceptingNewRequests && taskType == DatabaseTaskType::Normal)
+ return;
+
+ LockHolder locker(m_mainThreadTaskMutex);
+
+ m_mainThreadTasks.append(WTFMove(task));
+
+ RefPtr<LegacyUniqueIDBDatabase> database(this);
+ RunLoop::main().dispatch([database] {
+ database->performNextMainThreadTask();
+ });
+}
+
+bool LegacyUniqueIDBDatabase::performNextMainThreadTask()
+{
+ ASSERT(RunLoop::isMain());
+
+ bool moreTasks;
+
+ std::unique_ptr<CrossThreadTask> task;
+ {
+ LockHolder locker(m_mainThreadTaskMutex);
+
+ // This database might be shutting down, in which case the task queue might be empty.
+ if (m_mainThreadTasks.isEmpty())
+ return false;
+
+ task = m_mainThreadTasks.takeFirst();
+ moreTasks = !m_mainThreadTasks.isEmpty();
+ }
+
+ task->performTask();
+
+ return moreTasks;
+}
+
+void LegacyUniqueIDBDatabase::postDatabaseTask(std::unique_ptr<CrossThreadTask> task, DatabaseTaskType taskType)
+{
+ ASSERT(RunLoop::isMain());
+
+ if (!m_acceptingNewRequests && taskType == DatabaseTaskType::Normal)
+ return;
+
+ LockHolder locker(m_databaseTaskMutex);
+
+ m_databaseTasks.append(WTFMove(task));
+
+ RefPtr<LegacyUniqueIDBDatabase> database(this);
+ DatabaseProcess::singleton().queue().dispatch([database] {
+ database->performNextDatabaseTask();
+ });
+}
+
+void LegacyUniqueIDBDatabase::performNextDatabaseTask()
+{
+ ASSERT(!RunLoop::isMain());
+
+ // It is possible that this database might be shutting down on the main thread.
+ // In this case, immediately after releasing m_databaseTaskMutex, this database might get deleted.
+ // We take a ref() to make sure the database is still live while this last task is performed.
+ RefPtr<LegacyUniqueIDBDatabase> protector(this);
+
+ std::unique_ptr<CrossThreadTask> task;
+ {
+ LockHolder locker(m_databaseTaskMutex);
+
+ // This database might be shutting down on the main thread, in which case the task queue might be empty.
+ if (m_databaseTasks.isEmpty())
+ return;
+
+ task = m_databaseTasks.takeFirst();
+ }
+
+ task->performTask();
+}
+
+} // namespace WebKit
+
+#endif // ENABLE(INDEXED_DATABASE) && ENABLE(DATABASE_PROCESS)
</ins></span></pre></div>
<a id="trunkSourceWebKit2DatabaseProcessIndexedDBLegacyUniqueIDBDatabasehfromrev196734trunkSourceWebKit2DatabaseProcessIndexedDBUniqueIDBDatabaseh"></a>
<div class="copfile"><h4>Copied: trunk/Source/WebKit2/DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabase.h (from rev 196734, trunk/Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabase.h) (0 => 196735)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit2/DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabase.h (rev 0)
+++ trunk/Source/WebKit2/DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabase.h 2016-02-18 01:25:21 UTC (rev 196735)
</span><span class="lines">@@ -0,0 +1,221 @@
</span><ins>+/*
+ * Copyright (C) 2013 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. AND ITS CONTRIBUTORS ``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 ITS 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.
+ */
+
+#ifndef LegacyUniqueIDBDatabase_h
+#define LegacyUniqueIDBDatabase_h
+
+#if ENABLE(INDEXED_DATABASE) && ENABLE(DATABASE_PROCESS)
+
+#include "AsyncRequest.h"
+#include "IDBIdentifier.h"
+#include "LegacyUniqueIDBDatabaseIdentifier.h"
+#include <WebCore/IDBDatabaseBackend.h>
+#include <WebCore/IndexedDB.h>
+#include <functional>
+#include <wtf/Deque.h>
+#include <wtf/HashSet.h>
+#include <wtf/PassRefPtr.h>
+#include <wtf/RefCounted.h>
+#include <wtf/text/WTFString.h>
+
+namespace IPC {
+class DataReference;
+}
+
+namespace WebCore {
+class CrossThreadTask;
+class IDBGetResult;
+class IDBKeyData;
+class SharedBuffer;
+
+struct IDBDatabaseMetadata;
+struct IDBKeyRangeData;
+struct SecurityOriginData;
+}
+
+namespace WebKit {
+
+class DatabaseProcessIDBConnection;
+class UniqueIDBDatabaseBackingStore;
+
+enum class LegacyUniqueIDBDatabaseShutdownType {
+ NormalShutdown,
+ DeleteShutdown
+};
+
+class LegacyUniqueIDBDatabase : public ThreadSafeRefCounted<LegacyUniqueIDBDatabase> {
+public:
+ static Ref<LegacyUniqueIDBDatabase> create(const LegacyUniqueIDBDatabaseIdentifier& identifier)
+ {
+ return adoptRef(*new LegacyUniqueIDBDatabase(identifier));
+ }
+
+ ~LegacyUniqueIDBDatabase();
+
+ static String calculateAbsoluteDatabaseFilename(const String& absoluteDatabaseDirectory);
+
+ const LegacyUniqueIDBDatabaseIdentifier& identifier() const { return m_identifier; }
+
+ void registerConnection(DatabaseProcessIDBConnection&);
+ void unregisterConnection(DatabaseProcessIDBConnection&);
+
+ void deleteDatabase(std::function<void (bool)> successCallback);
+
+ void getOrEstablishIDBDatabaseMetadata(std::function<void (bool, const WebCore::IDBDatabaseMetadata&)> completionCallback);
+
+ void openTransaction(const IDBIdentifier& transactionIdentifier, const Vector<int64_t>& objectStoreIDs, WebCore::IndexedDB::TransactionMode, std::function<void (bool)> successCallback);
+ void beginTransaction(const IDBIdentifier& transactionIdentifier, std::function<void (bool)> successCallback);
+ void commitTransaction(const IDBIdentifier& transactionIdentifier, std::function<void (bool)> successCallback);
+ void resetTransaction(const IDBIdentifier& transactionIdentifier, std::function<void (bool)> successCallback);
+ void rollbackTransaction(const IDBIdentifier& transactionIdentifier, std::function<void (bool)> successCallback);
+
+ void changeDatabaseVersion(const IDBIdentifier& transactionIdentifier, uint64_t newVersion, std::function<void (bool)> successCallback);
+ void createObjectStore(const IDBIdentifier& transactionIdentifier, const WebCore::IDBObjectStoreMetadata&, std::function<void (bool)> successCallback);
+ void deleteObjectStore(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, std::function<void (bool)> successCallback);
+ void clearObjectStore(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, std::function<void (bool)> successCallback);
+ void createIndex(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const WebCore::IDBIndexMetadata&, std::function<void (bool)> successCallback);
+ void deleteIndex(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, std::function<void (bool)> successCallback);
+
+ void putRecord(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const WebCore::IDBKeyData&, const IPC::DataReference& value, int64_t putMode, const Vector<int64_t>& indexIDs, const Vector<Vector<WebCore::IDBKeyData>>& indexKeys, std::function<void (const WebCore::IDBKeyData&, uint32_t, const String&)> callback);
+ void getRecord(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, const WebCore::IDBKeyRangeData&, WebCore::IndexedDB::CursorType, std::function<void (const WebCore::IDBGetResult&, uint32_t, const String&)> callback);
+
+ void openCursor(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, WebCore::IndexedDB::CursorDirection, WebCore::IndexedDB::CursorType, WebCore::IDBDatabaseBackend::TaskType, const WebCore::IDBKeyRangeData&, std::function<void (int64_t, const WebCore::IDBKeyData&, const WebCore::IDBKeyData&, PassRefPtr<WebCore::SharedBuffer>, uint32_t, const String&)> callback);
+ void cursorAdvance(const IDBIdentifier& cursorIdentifier, uint64_t count, std::function<void (const WebCore::IDBKeyData&, const WebCore::IDBKeyData&, PassRefPtr<WebCore::SharedBuffer>, uint32_t, const String&)> callback);
+ void cursorIterate(const IDBIdentifier& cursorIdentifier, const WebCore::IDBKeyData&, std::function<void (const WebCore::IDBKeyData&, const WebCore::IDBKeyData&, PassRefPtr<WebCore::SharedBuffer>, uint32_t, const String&)> callback);
+
+ void count(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, const WebCore::IDBKeyRangeData&, std::function<void (int64_t, uint32_t, const String&)> callback);
+ void deleteRange(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const WebCore::IDBKeyRangeData&, std::function<void (uint32_t, const String&)> callback);
+
+private:
+ LegacyUniqueIDBDatabase(const LegacyUniqueIDBDatabaseIdentifier&);
+
+ LegacyUniqueIDBDatabaseIdentifier m_identifier;
+
+ bool m_inMemory;
+ String m_databaseRelativeDirectory;
+
+ HashSet<RefPtr<DatabaseProcessIDBConnection>> m_connections;
+ HashMap<uint64_t, RefPtr<AsyncRequest>> m_databaseRequests;
+
+ String absoluteDatabaseDirectory() const;
+
+ enum class DatabaseTaskType {
+ Normal,
+ Shutdown
+ };
+ void postDatabaseTask(std::unique_ptr<WebCore::CrossThreadTask>, DatabaseTaskType = DatabaseTaskType::Normal);
+
+ void shutdown(LegacyUniqueIDBDatabaseShutdownType);
+
+ // Method that attempts to make legal filenames from all legal database names
+ String filenameForDatabaseName() const;
+
+ // Returns a string that is appropriate for use as a unique filename
+ String databaseFilenameIdentifier(const WebCore::SecurityOriginData&) const;
+
+ // Returns true if this origin can use the same databases as the given origin.
+ bool canShareDatabases(const WebCore::SecurityOriginData&, const WebCore::SecurityOriginData&) const;
+
+ void postTransactionOperation(const IDBIdentifier& transactionIdentifier, std::unique_ptr<WebCore::CrossThreadTask>, std::function<void (bool)> successCallback);
+
+ // To be called from the database workqueue thread only
+ void performNextDatabaseTask();
+ void postMainThreadTask(std::unique_ptr<WebCore::CrossThreadTask>, DatabaseTaskType = DatabaseTaskType::Normal);
+ void openBackingStoreAndReadMetadata(const LegacyUniqueIDBDatabaseIdentifier&, const String& databaseDirectory);
+ void openBackingStoreTransaction(const IDBIdentifier& transactionIdentifier, const Vector<int64_t>& objectStoreIDs, WebCore::IndexedDB::TransactionMode);
+ void beginBackingStoreTransaction(const IDBIdentifier&);
+ void commitBackingStoreTransaction(const IDBIdentifier&);
+ void resetBackingStoreTransaction(const IDBIdentifier&);
+ void rollbackBackingStoreTransaction(const IDBIdentifier&);
+
+ void changeDatabaseVersionInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, uint64_t newVersion);
+ void createObjectStoreInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, const WebCore::IDBObjectStoreMetadata&);
+ void deleteObjectStoreInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID);
+ void clearObjectStoreInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID);
+
+ void createIndexInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const WebCore::IDBIndexMetadata&);
+ void deleteIndexInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID);
+
+ void putRecordInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, const WebCore::IDBObjectStoreMetadata&, const WebCore::IDBKeyData&, const Vector<uint8_t>& value, int64_t putMode, const Vector<int64_t>& indexIDs, const Vector<Vector<WebCore::IDBKeyData>>& indexKeys);
+ void getRecordFromBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, const WebCore::IDBObjectStoreMetadata&, int64_t indexID, const WebCore::IDBKeyRangeData&, WebCore::IndexedDB::CursorType);
+ void openCursorInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, WebCore::IndexedDB::CursorDirection, WebCore::IndexedDB::CursorType, WebCore::IDBDatabaseBackend::TaskType, const WebCore::IDBKeyRangeData&);
+ void advanceCursorInBackingStore(uint64_t requestID, const IDBIdentifier& cursorIdentifier, uint64_t count);
+ void iterateCursorInBackingStore(uint64_t requestID, const IDBIdentifier& cursorIdentifier, const WebCore::IDBKeyData&);
+ void countInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, const WebCore::IDBKeyRangeData&);
+ void deleteRangeInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const WebCore::IDBKeyRangeData&);
+
+ void shutdownBackingStore(LegacyUniqueIDBDatabaseShutdownType, const String& databaseDirectory);
+
+ // Callbacks from the database workqueue thread, to be performed on the main thread only
+ bool performNextMainThreadTask();
+ void didOpenBackingStoreAndReadMetadata(const WebCore::IDBDatabaseMetadata&, bool success);
+ void didCompleteTransactionOperation(const IDBIdentifier& transactionIdentifier, bool success);
+ void didChangeDatabaseVersion(uint64_t requestID, bool success);
+ void didCreateObjectStore(uint64_t requestID, bool success);
+ void didDeleteObjectStore(uint64_t requestID, bool success);
+ void didClearObjectStore(uint64_t requestID, bool success);
+ void didCreateIndex(uint64_t requestID, bool success);
+ void didDeleteIndex(uint64_t requestID, bool success);
+ void didPutRecordInBackingStore(uint64_t requestID, const WebCore::IDBKeyData&, uint32_t errorCode, const String& errorMessage);
+ void didGetRecordFromBackingStore(uint64_t requestID, const WebCore::IDBGetResult&, uint32_t errorCode, const String& errorMessage);
+ void didOpenCursorInBackingStore(uint64_t requestID, int64_t cursorID, const WebCore::IDBKeyData&, const WebCore::IDBKeyData&, const Vector<uint8_t>&, uint32_t errorCode, const String& errorMessage);
+ void didAdvanceCursorInBackingStore(uint64_t requestID, const WebCore::IDBKeyData&, const WebCore::IDBKeyData&, const Vector<uint8_t>&, uint32_t errorCode, const String& errorMessage);
+ void didIterateCursorInBackingStore(uint64_t requestID, const WebCore::IDBKeyData&, const WebCore::IDBKeyData&, const Vector<uint8_t>&, uint32_t errorCode, const String& errorMessage);
+ void didCountInBackingStore(uint64_t requestID, int64_t count, uint32_t errorCode, const String& errorMessage);
+ void didDeleteRangeInBackingStore(uint64_t requestID, uint32_t errorCode, const String& errorMessage);
+
+ void didShutdownBackingStore(LegacyUniqueIDBDatabaseShutdownType);
+ void didCompleteBoolRequest(uint64_t requestID, bool success);
+
+ void didEstablishTransaction(const IDBIdentifier& transactionIdentifier, bool success);
+ void didResetTransaction(const IDBIdentifier& transactionIdentifier, bool success);
+ void resetAllTransactions(const DatabaseProcessIDBConnection&);
+ void finalizeRollback(const IDBIdentifier& transactionId);
+
+ bool m_acceptingNewRequests;
+
+ HashMap<const DatabaseProcessIDBConnection*, HashSet<IDBIdentifier>> m_establishedTransactions;
+ Deque<RefPtr<AsyncRequest>> m_pendingMetadataRequests;
+ HashMap<IDBIdentifier, RefPtr<AsyncRequest>> m_pendingTransactionRequests;
+ HashSet<IDBIdentifier> m_pendingTransactionRollbacks;
+ AsyncRequestMap m_pendingDatabaseTasks;
+ RefPtr<AsyncRequest> m_pendingShutdownTask;
+
+ std::unique_ptr<WebCore::IDBDatabaseMetadata> m_metadata;
+ bool m_didGetMetadataFromBackingStore;
+
+ RefPtr<UniqueIDBDatabaseBackingStore> m_backingStore;
+
+ Deque<std::unique_ptr<WebCore::CrossThreadTask>> m_databaseTasks;
+ Lock m_databaseTaskMutex;
+
+ Deque<std::unique_ptr<WebCore::CrossThreadTask>> m_mainThreadTasks;
+ Lock m_mainThreadTaskMutex;
+};
+
+} // namespace WebKit
+
+#endif // ENABLE(INDEXED_DATABASE) && ENABLE(DATABASE_PROCESS)
+#endif // LegacyUniqueIDBDatabase_h
</ins></span></pre></div>
<a id="trunkSourceWebKit2DatabaseProcessIndexedDBLegacyUniqueIDBDatabaseIdentifiercppfromrev196734trunkSourceWebKit2DatabaseProcessIndexedDBUniqueIDBDatabaseIdentifiercpp"></a>
<div class="copfile"><h4>Copied: trunk/Source/WebKit2/DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabaseIdentifier.cpp (from rev 196734, trunk/Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabaseIdentifier.cpp) (0 => 196735)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit2/DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabaseIdentifier.cpp (rev 0)
+++ trunk/Source/WebKit2/DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabaseIdentifier.cpp 2016-02-18 01:25:21 UTC (rev 196735)
</span><span class="lines">@@ -0,0 +1,101 @@
</span><ins>+/*
+ * Copyright (C) 2013 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. AND ITS CONTRIBUTORS ``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 ITS 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 "LegacyUniqueIDBDatabaseIdentifier.h"
+
+#if ENABLE(INDEXED_DATABASE) && ENABLE(DATABASE_PROCESS)
+
+#include <wtf/text/StringBuilder.h>
+
+namespace WebKit {
+
+LegacyUniqueIDBDatabaseIdentifier::LegacyUniqueIDBDatabaseIdentifier()
+{
+}
+
+LegacyUniqueIDBDatabaseIdentifier::LegacyUniqueIDBDatabaseIdentifier(const String& databaseName, const WebCore::SecurityOriginData& openingOrigin, const WebCore::SecurityOriginData& mainFrameOrigin)
+ : m_databaseName(databaseName)
+ , m_openingOrigin(openingOrigin)
+ , m_mainFrameOrigin(mainFrameOrigin)
+{
+ // While it is valid to have an empty database name, it is not valid to have a null one.
+ ASSERT(!m_databaseName.isNull());
+}
+
+LegacyUniqueIDBDatabaseIdentifier::LegacyUniqueIDBDatabaseIdentifier(WTF::HashTableDeletedValueType)
+ : m_databaseName(WTF::HashTableDeletedValue)
+{
+}
+
+bool LegacyUniqueIDBDatabaseIdentifier::isHashTableDeletedValue() const
+{
+ return m_databaseName.isHashTableDeletedValue();
+}
+
+unsigned LegacyUniqueIDBDatabaseIdentifier::hash() const
+{
+ unsigned hashCodes[7] = {
+ m_databaseName.impl() ? m_databaseName.impl()->hash() : 0,
+ m_openingOrigin.protocol.impl() ? m_openingOrigin.protocol.impl()->hash() : 0,
+ m_openingOrigin.host.impl() ? m_openingOrigin.host.impl()->hash() : 0,
+ static_cast<unsigned>(m_openingOrigin.port),
+ m_mainFrameOrigin.protocol.impl() ? m_mainFrameOrigin.protocol.impl()->hash() : 0,
+ m_mainFrameOrigin.host.impl() ? m_mainFrameOrigin.host.impl()->hash() : 0,
+ static_cast<unsigned>(m_mainFrameOrigin.port)
+ };
+ return StringHasher::hashMemory<sizeof(hashCodes)>(hashCodes);
+}
+
+bool LegacyUniqueIDBDatabaseIdentifier::isNull() const
+{
+ // Only a default constructed LegacyUniqueIDBDatabaseIdentifier can have a null database name.
+ return m_databaseName.isNull();
+}
+
+LegacyUniqueIDBDatabaseIdentifier LegacyUniqueIDBDatabaseIdentifier::isolatedCopy() const
+{
+ LegacyUniqueIDBDatabaseIdentifier result;
+
+ result.m_databaseName = m_databaseName.isolatedCopy();
+ result.m_openingOrigin = m_openingOrigin.isolatedCopy();
+ result.m_mainFrameOrigin = m_mainFrameOrigin.isolatedCopy();
+
+ return result;
+}
+
+bool operator==(const LegacyUniqueIDBDatabaseIdentifier& a, const LegacyUniqueIDBDatabaseIdentifier& b)
+{
+ if (&a == &b)
+ return true;
+
+ return a.databaseName() == b.databaseName()
+ && a.openingOrigin() == b.openingOrigin()
+ && a.mainFrameOrigin() == b.mainFrameOrigin();
+}
+
+} // namespace WebKit
+
+#endif // ENABLE(INDEXED_DATABASE) && ENABLE(DATABASE_PROCESS)
</ins></span></pre></div>
<a id="trunkSourceWebKit2DatabaseProcessIndexedDBLegacyUniqueIDBDatabaseIdentifierhfromrev196734trunkSourceWebKit2DatabaseProcessIndexedDBUniqueIDBDatabaseIdentifierh"></a>
<div class="copfile"><h4>Copied: trunk/Source/WebKit2/DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabaseIdentifier.h (from rev 196734, trunk/Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabaseIdentifier.h) (0 => 196735)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit2/DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabaseIdentifier.h (rev 0)
+++ trunk/Source/WebKit2/DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabaseIdentifier.h 2016-02-18 01:25:21 UTC (rev 196735)
</span><span class="lines">@@ -0,0 +1,86 @@
</span><ins>+/*
+ * Copyright (C) 2013 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. AND ITS CONTRIBUTORS ``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 ITS 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.
+ */
+
+#ifndef LegacyUniqueIDBDatabaseIdentifier_h
+#define LegacyUniqueIDBDatabaseIdentifier_h
+
+#if ENABLE(INDEXED_DATABASE) && ENABLE(DATABASE_PROCESS)
+
+#include <WebCore/SecurityOriginData.h>
+#include <wtf/PassRefPtr.h>
+#include <wtf/RefCounted.h>
+#include <wtf/text/WTFString.h>
+
+namespace WebKit {
+
+class LegacyUniqueIDBDatabaseIdentifier {
+public:
+ LegacyUniqueIDBDatabaseIdentifier();
+ LegacyUniqueIDBDatabaseIdentifier(const String& databaseName, const WebCore::SecurityOriginData& openingOrigin, const WebCore::SecurityOriginData& mainFrameOrigin);
+
+ bool isNull() const;
+
+ const String& databaseName() const { return m_databaseName; }
+ const WebCore::SecurityOriginData& openingOrigin() const { return m_openingOrigin; }
+ const WebCore::SecurityOriginData& mainFrameOrigin() const { return m_mainFrameOrigin; }
+
+ LegacyUniqueIDBDatabaseIdentifier(WTF::HashTableDeletedValueType);
+ bool isHashTableDeletedValue() const;
+ unsigned hash() const;
+
+ LegacyUniqueIDBDatabaseIdentifier isolatedCopy() const;
+
+private:
+ String m_databaseName;
+ WebCore::SecurityOriginData m_openingOrigin;
+ WebCore::SecurityOriginData m_mainFrameOrigin;
+};
+
+bool operator==(const LegacyUniqueIDBDatabaseIdentifier&, const LegacyUniqueIDBDatabaseIdentifier&);
+
+struct LegacyUniqueIDBDatabaseIdentifierHash {
+ static unsigned hash(const LegacyUniqueIDBDatabaseIdentifier& identifier) { return identifier.hash(); }
+ static bool equal(const LegacyUniqueIDBDatabaseIdentifier& a, const LegacyUniqueIDBDatabaseIdentifier& b) { return a == b; }
+ static const bool safeToCompareToEmptyOrDeleted = false;
+};
+
+struct LegacyUniqueIDBDatabaseIdentifierHashTraits : WTF::SimpleClassHashTraits<LegacyUniqueIDBDatabaseIdentifier> {
+ static const bool hasIsEmptyValueFunction = true;
+ static bool isEmptyValue(const LegacyUniqueIDBDatabaseIdentifier& info) { return info.isNull(); }
+};
+
+} // namespace WebKit
+
+namespace WTF {
+
+template<> struct HashTraits<WebKit::LegacyUniqueIDBDatabaseIdentifier> : WebKit::LegacyUniqueIDBDatabaseIdentifierHashTraits { };
+template<> struct DefaultHash<WebKit::LegacyUniqueIDBDatabaseIdentifier> {
+ typedef WebKit::LegacyUniqueIDBDatabaseIdentifierHash Hash;
+};
+
+} // namespaec WTF
+
+#endif // ENABLE(INDEXED_DATABASE) && ENABLE(DATABASE_PROCESS)
+#endif // LegacyUniqueIDBDatabaseIdentifier_h
</ins></span></pre></div>
<a id="trunkSourceWebKit2DatabaseProcessIndexedDBUniqueIDBDatabasecpp"></a>
<div class="delfile"><h4>Deleted: trunk/Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabase.cpp (196734 => 196735)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabase.cpp 2016-02-18 01:17:36 UTC (rev 196734)
+++ trunk/Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabase.cpp 2016-02-18 01:25:21 UTC (rev 196735)
</span><span class="lines">@@ -1,1203 +0,0 @@
</span><del>-/*
- * Copyright (C) 2013 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. AND ITS CONTRIBUTORS ``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 ITS 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 "UniqueIDBDatabase.h"
-
-#if ENABLE(INDEXED_DATABASE) && ENABLE(DATABASE_PROCESS)
-
-#include "AsyncRequest.h"
-#include "DataReference.h"
-#include "DatabaseProcess.h"
-#include "DatabaseProcessIDBConnection.h"
-#include "Logging.h"
-#include "UniqueIDBDatabaseBackingStoreSQLite.h"
-#include "WebCrossThreadCopier.h"
-#include <WebCore/CrossThreadTask.h>
-#include <WebCore/FileSystem.h>
-#include <WebCore/IDBDatabaseMetadata.h>
-#include <WebCore/IDBGetResult.h>
-#include <WebCore/IDBKeyData.h>
-#include <WebCore/IDBKeyRangeData.h>
-#include <WebCore/SecurityOrigin.h>
-#include <wtf/MainThread.h>
-#include <wtf/text/WTFString.h>
-
-using namespace WebCore;
-
-namespace WebKit {
-
-String UniqueIDBDatabase::calculateAbsoluteDatabaseFilename(const String& absoluteDatabaseDirectory)
-{
- return pathByAppendingComponent(absoluteDatabaseDirectory, "IndexedDB.sqlite3");
-}
-
-UniqueIDBDatabase::UniqueIDBDatabase(const UniqueIDBDatabaseIdentifier& identifier)
- : m_identifier(identifier)
- , m_acceptingNewRequests(true)
- , m_didGetMetadataFromBackingStore(false)
-{
- m_inMemory = !canShareDatabases(identifier.openingOrigin(), identifier.mainFrameOrigin());
- if (m_inMemory)
- return;
-
- // *********
- // IMPORTANT: Do not change the directory structure for indexed databases on disk without first consulting a reviewer from Apple (<rdar://problem/17454712>)
- // *********
-
- // Each unique Indexed Database exists in a directory named for the database, which exists in a directory representing its opening origin.
- m_databaseRelativeDirectory = pathByAppendingComponent(databaseFilenameIdentifier(identifier.openingOrigin()), filenameForDatabaseName());
-
- DatabaseProcess::singleton().ensureIndexedDatabaseRelativePathExists(m_databaseRelativeDirectory);
-}
-
-UniqueIDBDatabase::~UniqueIDBDatabase()
-{
- ASSERT(!m_acceptingNewRequests);
- ASSERT(m_pendingMetadataRequests.isEmpty());
-}
-
-String UniqueIDBDatabase::filenameForDatabaseName() const
-{
- ASSERT(!m_identifier.databaseName().isNull());
-
- if (m_identifier.databaseName().isEmpty())
- return "%00";
-
- String filename = encodeForFileName(m_identifier.databaseName());
- filename.replace('.', "%2E");
-
- return filename;
-}
-
-String UniqueIDBDatabase::databaseFilenameIdentifier(const SecurityOriginData& originData) const
-{
- Ref<SecurityOrigin> securityOrigin(SecurityOrigin::create(originData.protocol, originData.host, originData.port));
- return securityOrigin.get().databaseIdentifier();
-}
-
-bool UniqueIDBDatabase::canShareDatabases(const SecurityOriginData& openingOrigin, const SecurityOriginData& mainFrameOrigin) const
-{
- // For now, an origin's database access is predicated on equality with the other origin.
- // We might need to make this more nuanced later.
- return openingOrigin == mainFrameOrigin;
-}
-
-void UniqueIDBDatabase::registerConnection(DatabaseProcessIDBConnection& connection)
-{
- ASSERT(!m_connections.contains(&connection));
- m_connections.add(&connection);
-}
-
-void UniqueIDBDatabase::unregisterConnection(DatabaseProcessIDBConnection& connection)
-{
- ASSERT(m_connections.contains(&connection));
- resetAllTransactions(connection);
- m_connections.remove(&connection);
-
- if (m_connections.isEmpty() && m_pendingTransactionRollbacks.isEmpty()) {
- shutdown(UniqueIDBDatabaseShutdownType::NormalShutdown);
- DatabaseProcess::singleton().removeUniqueIDBDatabase(*this);
- }
-}
-
-void UniqueIDBDatabase::shutdown(UniqueIDBDatabaseShutdownType type)
-{
- ASSERT(RunLoop::isMain());
-
- if (!m_acceptingNewRequests)
- return;
-
- m_acceptingNewRequests = false;
-
- // Balanced by an adoptRef in ::didShutdownBackingStore()
- ref();
-
- {
- LockHolder locker(m_databaseTaskMutex);
- m_databaseTasks.clear();
- }
-
- postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::shutdownBackingStore, type, absoluteDatabaseDirectory()), DatabaseTaskType::Shutdown);
-}
-
-void UniqueIDBDatabase::shutdownBackingStore(UniqueIDBDatabaseShutdownType type, const String& databaseDirectory)
-{
- ASSERT(!RunLoop::isMain());
-
- m_backingStore = nullptr;
-
- if (type == UniqueIDBDatabaseShutdownType::DeleteShutdown) {
- String dbFilename = UniqueIDBDatabase::calculateAbsoluteDatabaseFilename(databaseDirectory);
- LOG(IDB, "UniqueIDBDatabase::shutdownBackingStore deleting file '%s' on disk", dbFilename.utf8().data());
- deleteFile(dbFilename);
- deleteEmptyDirectory(databaseDirectory);
- }
-
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didShutdownBackingStore, type), DatabaseTaskType::Shutdown);
-}
-
-void UniqueIDBDatabase::didShutdownBackingStore(UniqueIDBDatabaseShutdownType type)
-{
- ASSERT(RunLoop::isMain());
-
- // Balanced by a ref in ::shutdown()
- RefPtr<UniqueIDBDatabase> protector(adoptRef(this));
-
- // Empty out remaining main thread tasks.
- while (performNextMainThreadTask()) {
- }
-
- // No more requests will be handled, so abort all outstanding requests.
- for (const auto& request : m_pendingMetadataRequests)
- request->requestAborted();
- for (const auto& request : m_pendingTransactionRequests.values())
- request->requestAborted();
- for (const auto& request : m_pendingDatabaseTasks.values())
- request->requestAborted();
-
- m_pendingMetadataRequests.clear();
- m_pendingTransactionRequests.clear();
- m_pendingDatabaseTasks.clear();
-
- if (m_pendingShutdownTask)
- m_pendingShutdownTask->completeRequest(type);
-
- m_pendingShutdownTask = nullptr;
-}
-
-void UniqueIDBDatabase::deleteDatabase(std::function<void (bool)> successCallback)
-{
- ASSERT(RunLoop::isMain());
-
- if (!m_acceptingNewRequests) {
- // Someone else has already shutdown this database, so we can't request a delete.
- callOnMainThread([successCallback] {
- successCallback(false);
- });
- return;
- }
-
- RefPtr<UniqueIDBDatabase> protector(this);
- m_pendingShutdownTask = AsyncRequestImpl<UniqueIDBDatabaseShutdownType>::create([this, protector, successCallback](UniqueIDBDatabaseShutdownType type) {
- // If the shutdown just completed was a Delete shutdown then we succeeded.
- // If not report failure instead of trying again.
- successCallback(type == UniqueIDBDatabaseShutdownType::DeleteShutdown);
- }, [this, protector, successCallback] {
- successCallback(false);
- });
-
- shutdown(UniqueIDBDatabaseShutdownType::DeleteShutdown);
-}
-
-void UniqueIDBDatabase::getOrEstablishIDBDatabaseMetadata(std::function<void (bool, const IDBDatabaseMetadata&)> completionCallback)
-{
- ASSERT(RunLoop::isMain());
-
- if (!m_acceptingNewRequests) {
- completionCallback(false, IDBDatabaseMetadata());
- return;
- }
-
- // If we've already retrieved metadata from the backing store, return it now.
- if (m_didGetMetadataFromBackingStore) {
- if (m_metadata)
- completionCallback(true, *m_metadata);
- else
- completionCallback(false, IDBDatabaseMetadata());
-
- return;
- }
-
- // If this is the first unanswered metadata request, then later we need to
- // post a task to open the backing store and get metadata.
- bool shouldOpenBackingStore = m_pendingMetadataRequests.isEmpty();
-
- // Then remember this metadata request to be answered later.
- RefPtr<AsyncRequest> request = AsyncRequestImpl<>::create([completionCallback, this] {
- completionCallback(!!m_metadata, m_metadata ? *m_metadata : IDBDatabaseMetadata());
- }, [completionCallback] {
- // The boolean flag to the completion callback represents whether the
- // attempt to get/establish metadata succeeded or failed.
- // Since we're aborting the attempt, it failed, so we always pass in false.
- completionCallback(false, IDBDatabaseMetadata());
- });
-
- m_pendingMetadataRequests.append(request.release());
-
- if (shouldOpenBackingStore)
- postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::openBackingStoreAndReadMetadata, m_identifier, absoluteDatabaseDirectory()));
-}
-
-void UniqueIDBDatabase::openBackingStoreAndReadMetadata(const UniqueIDBDatabaseIdentifier& identifier, const String& databaseDirectory)
-{
- ASSERT(!RunLoop::isMain());
- ASSERT(!m_backingStore);
-
- if (m_inMemory) {
- LOG_ERROR("Support for in-memory databases not yet implemented");
- return;
- }
-
- m_backingStore = UniqueIDBDatabaseBackingStoreSQLite::create(identifier, databaseDirectory);
- std::unique_ptr<IDBDatabaseMetadata> metadata = m_backingStore->getOrEstablishMetadata();
-
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didOpenBackingStoreAndReadMetadata, metadata ? *metadata : IDBDatabaseMetadata(), !!metadata));
-}
-
-void UniqueIDBDatabase::didOpenBackingStoreAndReadMetadata(const IDBDatabaseMetadata& metadata, bool success)
-{
- ASSERT(RunLoop::isMain());
- ASSERT(!m_metadata);
-
- m_didGetMetadataFromBackingStore = true;
-
- if (success)
- m_metadata = std::make_unique<IDBDatabaseMetadata>(metadata);
-
- while (!m_pendingMetadataRequests.isEmpty()) {
- RefPtr<AsyncRequest> request = m_pendingMetadataRequests.takeFirst();
- request->completeRequest();
- }
-}
-
-void UniqueIDBDatabase::openTransaction(const IDBIdentifier& transactionIdentifier, const Vector<int64_t>& objectStoreIDs, IndexedDB::TransactionMode mode, std::function<void (bool)> successCallback)
-{
- postTransactionOperation(transactionIdentifier, createCrossThreadTask(*this, &UniqueIDBDatabase::openBackingStoreTransaction, transactionIdentifier, objectStoreIDs, mode), successCallback);
-}
-
-void UniqueIDBDatabase::beginTransaction(const IDBIdentifier& transactionIdentifier, std::function<void (bool)> successCallback)
-{
- postTransactionOperation(transactionIdentifier, createCrossThreadTask(*this, &UniqueIDBDatabase::beginBackingStoreTransaction, transactionIdentifier), successCallback);
-}
-
-void UniqueIDBDatabase::commitTransaction(const IDBIdentifier& transactionIdentifier, std::function<void (bool)> successCallback)
-{
- postTransactionOperation(transactionIdentifier, createCrossThreadTask(*this, &UniqueIDBDatabase::commitBackingStoreTransaction, transactionIdentifier), successCallback);
-}
-
-void UniqueIDBDatabase::resetTransaction(const IDBIdentifier& transactionIdentifier, std::function<void (bool)> successCallback)
-{
- postTransactionOperation(transactionIdentifier, createCrossThreadTask(*this, &UniqueIDBDatabase::resetBackingStoreTransaction, transactionIdentifier), successCallback);
-}
-
-void UniqueIDBDatabase::rollbackTransaction(const IDBIdentifier& transactionIdentifier, std::function<void (bool)> successCallback)
-{
- postTransactionOperation(transactionIdentifier, createCrossThreadTask(*this, &UniqueIDBDatabase::rollbackBackingStoreTransaction, transactionIdentifier), successCallback);
-}
-
-void UniqueIDBDatabase::postTransactionOperation(const IDBIdentifier& transactionIdentifier, std::unique_ptr<CrossThreadTask> task, std::function<void (bool)> successCallback)
-{
- ASSERT(RunLoop::isMain());
-
- if (!m_acceptingNewRequests) {
- successCallback(false);
- return;
- }
-
- if (m_pendingTransactionRequests.contains(transactionIdentifier)) {
- LOG_ERROR("Attempting to queue an operation for a transaction that already has an operation pending. Each transaction should only have one operation pending at a time.");
- successCallback(false);
- return;
- }
-
- postDatabaseTask(WTFMove(task));
-
- RefPtr<AsyncRequest> request = AsyncRequestImpl<bool>::create([successCallback](bool success) {
- successCallback(success);
- }, [successCallback] {
- successCallback(false);
- });
-
- m_pendingTransactionRequests.add(transactionIdentifier, request.release());
-}
-
-void UniqueIDBDatabase::didCompleteTransactionOperation(const IDBIdentifier& transactionIdentifier, bool success)
-{
- ASSERT(RunLoop::isMain());
-
- RefPtr<AsyncRequest> request = m_pendingTransactionRequests.take(transactionIdentifier);
-
- if (request)
- request->completeRequest(success);
-
- if (m_pendingTransactionRollbacks.contains(transactionIdentifier))
- finalizeRollback(transactionIdentifier);
-}
-
-void UniqueIDBDatabase::changeDatabaseVersion(const IDBIdentifier& transactionIdentifier, uint64_t newVersion, std::function<void (bool)> successCallback)
-{
- ASSERT(RunLoop::isMain());
-
- if (!m_acceptingNewRequests) {
- successCallback(false);
- return;
- }
-
- uint64_t oldVersion = m_metadata->version;
- m_metadata->version = newVersion;
-
- RefPtr<AsyncRequest> request = AsyncRequestImpl<bool>::create([this, oldVersion, successCallback](bool success) {
- if (!success)
- m_metadata->version = oldVersion;
- successCallback(success);
- }, [this, oldVersion, successCallback] {
- m_metadata->version = oldVersion;
- successCallback(false);
- });
-
- uint64_t requestID = request->requestID();
- m_pendingDatabaseTasks.add(requestID, request.release());
-
- postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::changeDatabaseVersionInBackingStore, requestID, transactionIdentifier, newVersion));
-}
-
-void UniqueIDBDatabase::didChangeDatabaseVersion(uint64_t requestID, bool success)
-{
- didCompleteBoolRequest(requestID, success);
-}
-
-void UniqueIDBDatabase::didCreateObjectStore(uint64_t requestID, bool success)
-{
- didCompleteBoolRequest(requestID, success);
-}
-
-void UniqueIDBDatabase::didDeleteObjectStore(uint64_t requestID, bool success)
-{
- didCompleteBoolRequest(requestID, success);
-}
-
-void UniqueIDBDatabase::didClearObjectStore(uint64_t requestID, bool success)
-{
- didCompleteBoolRequest(requestID, success);
-}
-
-void UniqueIDBDatabase::didCreateIndex(uint64_t requestID, bool success)
-{
- didCompleteBoolRequest(requestID, success);
-}
-
-void UniqueIDBDatabase::didDeleteIndex(uint64_t requestID, bool success)
-{
- didCompleteBoolRequest(requestID, success);
-}
-
-void UniqueIDBDatabase::didCompleteBoolRequest(uint64_t requestID, bool success)
-{
- m_pendingDatabaseTasks.take(requestID).get().completeRequest(success);
-}
-
-void UniqueIDBDatabase::createObjectStore(const IDBIdentifier& transactionIdentifier, const IDBObjectStoreMetadata& metadata, std::function<void (bool)> successCallback)
-{
- ASSERT(RunLoop::isMain());
-
- if (!m_acceptingNewRequests) {
- successCallback(false);
- return;
- }
-
- ASSERT(!m_metadata->objectStores.contains(metadata.id));
- m_metadata->objectStores.set(metadata.id, metadata);
- int64_t addedObjectStoreID = metadata.id;
-
- RefPtr<AsyncRequest> request = AsyncRequestImpl<bool>::create([this, addedObjectStoreID, successCallback](bool success) {
- if (!success)
- m_metadata->objectStores.remove(addedObjectStoreID);
- successCallback(success);
- }, [this, addedObjectStoreID, successCallback] {
- m_metadata->objectStores.remove(addedObjectStoreID);
- successCallback(false);
- });
-
- uint64_t requestID = request->requestID();
- m_pendingDatabaseTasks.add(requestID, request.release());
-
- postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::createObjectStoreInBackingStore, requestID, transactionIdentifier, metadata));
-}
-
-void UniqueIDBDatabase::deleteObjectStore(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, std::function<void (bool)> successCallback)
-{
- ASSERT(RunLoop::isMain());
-
- if (!m_acceptingNewRequests) {
- successCallback(false);
- return;
- }
-
- ASSERT(m_metadata->objectStores.contains(objectStoreID));
- IDBObjectStoreMetadata metadata = m_metadata->objectStores.take(objectStoreID);
-
- RefPtr<AsyncRequest> request = AsyncRequestImpl<bool>::create([this, metadata, successCallback](bool success) {
- if (!success)
- m_metadata->objectStores.set(metadata.id, metadata);
- successCallback(success);
- }, [this, metadata, successCallback] {
- m_metadata->objectStores.set(metadata.id, metadata);
- successCallback(false);
- });
-
- uint64_t requestID = request->requestID();
- m_pendingDatabaseTasks.add(requestID, request.release());
-
- postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::deleteObjectStoreInBackingStore, requestID, transactionIdentifier, objectStoreID));
-}
-
-void UniqueIDBDatabase::clearObjectStore(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, std::function<void (bool)> successCallback)
-{
- ASSERT(RunLoop::isMain());
-
- if (!m_acceptingNewRequests) {
- successCallback(false);
- return;
- }
-
- ASSERT(m_metadata->objectStores.contains(objectStoreID));
-
- RefPtr<AsyncRequest> request = AsyncRequestImpl<bool>::create([this, successCallback](bool success) {
- successCallback(success);
- }, [this, successCallback] {
- successCallback(false);
- });
-
- uint64_t requestID = request->requestID();
- m_pendingDatabaseTasks.add(requestID, request.release());
-
- postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::clearObjectStoreInBackingStore, requestID, transactionIdentifier, objectStoreID));
-}
-
-void UniqueIDBDatabase::createIndex(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const IDBIndexMetadata& metadata, std::function<void (bool)> successCallback)
-{
- ASSERT(RunLoop::isMain());
-
- if (!m_acceptingNewRequests) {
- successCallback(false);
- return;
- }
-
- ASSERT(m_metadata->objectStores.contains(objectStoreID));
- ASSERT(!m_metadata->objectStores.get(objectStoreID).indexes.contains(metadata.id));
- m_metadata->objectStores.get(objectStoreID).indexes.set(metadata.id, metadata);
- int64_t addedIndexID = metadata.id;
-
- RefPtr<AsyncRequest> request = AsyncRequestImpl<bool>::create([this, objectStoreID, addedIndexID, successCallback](bool success) {
- if (!success) {
- auto objectStoreFind = m_metadata->objectStores.find(objectStoreID);
- if (objectStoreFind != m_metadata->objectStores.end())
- objectStoreFind->value.indexes.remove(addedIndexID);
- }
- successCallback(success);
- }, [this, objectStoreID, addedIndexID, successCallback] {
- auto objectStoreFind = m_metadata->objectStores.find(objectStoreID);
- if (objectStoreFind != m_metadata->objectStores.end())
- objectStoreFind->value.indexes.remove(addedIndexID);
- successCallback(false);
- });
-
- uint64_t requestID = request->requestID();
- m_pendingDatabaseTasks.add(requestID, request.release());
-
- postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::createIndexInBackingStore, requestID, transactionIdentifier, objectStoreID, metadata));
-}
-
-void UniqueIDBDatabase::deleteIndex(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, std::function<void (bool)> successCallback)
-{
- ASSERT(RunLoop::isMain());
-
- if (!m_acceptingNewRequests) {
- successCallback(false);
- return;
- }
-
- ASSERT(m_metadata->objectStores.contains(objectStoreID));
- ASSERT(m_metadata->objectStores.get(objectStoreID).indexes.contains(indexID));
-
- IDBIndexMetadata metadata = m_metadata->objectStores.get(objectStoreID).indexes.take(indexID);
-
- RefPtr<AsyncRequest> request = AsyncRequestImpl<bool>::create([this, objectStoreID, metadata, successCallback](bool success) {
- if (!success) {
- auto objectStoreFind = m_metadata->objectStores.find(objectStoreID);
- if (objectStoreFind != m_metadata->objectStores.end())
- objectStoreFind->value.indexes.set(metadata.id, metadata);
- }
- successCallback(success);
- }, [this, objectStoreID, metadata, successCallback] {
- auto objectStoreFind = m_metadata->objectStores.find(objectStoreID);
- if (objectStoreFind != m_metadata->objectStores.end())
- objectStoreFind->value.indexes.set(metadata.id, metadata);
- successCallback(false);
- });
-
- uint64_t requestID = request->requestID();
- m_pendingDatabaseTasks.add(requestID, request.release());
-
- postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::deleteIndexInBackingStore, requestID, transactionIdentifier, objectStoreID, indexID));
-}
-
-void UniqueIDBDatabase::putRecord(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const IDBKeyData& keyData, const IPC::DataReference& value, int64_t putMode, const Vector<int64_t>& indexIDs, const Vector<Vector<IDBKeyData>>& indexKeys, std::function<void (const IDBKeyData&, uint32_t, const String&)> callback)
-{
- ASSERT(RunLoop::isMain());
-
- if (!m_acceptingNewRequests) {
- callback(IDBKeyData(), INVALID_STATE_ERR, "Unable to put record into database because it has shut down");
- return;
- }
-
- ASSERT(m_metadata->objectStores.contains(objectStoreID));
-
- RefPtr<AsyncRequest> request = AsyncRequestImpl<IDBKeyData, uint32_t, String>::create([this, callback](const IDBKeyData& keyData, uint32_t errorCode, const String& errorMessage) {
- callback(keyData, errorCode, errorMessage);
- }, [this, callback] {
- callback(IDBKeyData(), INVALID_STATE_ERR, "Unable to put record into database");
- });
-
- uint64_t requestID = request->requestID();
- m_pendingDatabaseTasks.add(requestID, request.release());
-
- postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::putRecordInBackingStore, requestID, transactionIdentifier, m_metadata->objectStores.get(objectStoreID), keyData, value.vector(), putMode, indexIDs, indexKeys));
-}
-
-void UniqueIDBDatabase::getRecord(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, const IDBKeyRangeData& keyRangeData, IndexedDB::CursorType cursorType, std::function<void (const IDBGetResult&, uint32_t, const String&)> callback)
-{
- ASSERT(RunLoop::isMain());
-
- if (!m_acceptingNewRequests) {
- callback(IDBGetResult(), INVALID_STATE_ERR, "Unable to get record from database because it has shut down");
- return;
- }
-
- ASSERT(m_metadata->objectStores.contains(objectStoreID));
-
- RefPtr<AsyncRequest> request = AsyncRequestImpl<IDBGetResult, uint32_t, String>::create([this, callback](const IDBGetResult& result, uint32_t errorCode, const String& errorMessage) {
- callback(result, errorCode, errorMessage);
- }, [this, callback] {
- callback(IDBGetResult(), INVALID_STATE_ERR, "Unable to get record from database");
- });
-
- uint64_t requestID = request->requestID();
- m_pendingDatabaseTasks.add(requestID, request.release());
-
- postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::getRecordFromBackingStore, requestID, transactionIdentifier, m_metadata->objectStores.get(objectStoreID), indexID, keyRangeData, cursorType));
-}
-
-void UniqueIDBDatabase::openCursor(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, IndexedDB::CursorDirection cursorDirection, IndexedDB::CursorType cursorType, IDBDatabaseBackend::TaskType taskType, const IDBKeyRangeData& keyRangeData, std::function<void (int64_t, const IDBKeyData&, const IDBKeyData&, PassRefPtr<SharedBuffer>, uint32_t, const String&)> callback)
-{
- ASSERT(RunLoop::isMain());
-
- if (!m_acceptingNewRequests) {
- callback(0, nullptr, nullptr, nullptr, INVALID_STATE_ERR, "Unable to open cursor in database because it has shut down");
- return;
- }
-
- ASSERT(m_metadata->objectStores.contains(objectStoreID));
-
- RefPtr<AsyncRequest> request = AsyncRequestImpl<int64_t, IDBKeyData, IDBKeyData, PassRefPtr<SharedBuffer>, uint32_t, String>::create([this, callback](int64_t cursorID, const IDBKeyData& key, const IDBKeyData& primaryKey, PassRefPtr<SharedBuffer> value, uint32_t errorCode, const String& errorMessage) {
- callback(cursorID, key, primaryKey, value, errorCode, errorMessage);
- }, [this, callback] {
- callback(0, nullptr, nullptr, nullptr, INVALID_STATE_ERR, "Unable to get record from database");
- });
-
- uint64_t requestID = request->requestID();
- m_pendingDatabaseTasks.add(requestID, request.release());
-
- postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::openCursorInBackingStore, requestID, transactionIdentifier, objectStoreID, indexID, cursorDirection, cursorType, taskType, keyRangeData));
-}
-
-void UniqueIDBDatabase::cursorAdvance(const IDBIdentifier& cursorIdentifier, uint64_t count, std::function<void (const IDBKeyData&, const IDBKeyData&, PassRefPtr<SharedBuffer>, uint32_t, const String&)> callback)
-{
- ASSERT(RunLoop::isMain());
-
- if (!m_acceptingNewRequests) {
- callback(nullptr, nullptr, nullptr, INVALID_STATE_ERR, "Unable to advance cursor in database because it has shut down");
- return;
- }
-
- RefPtr<AsyncRequest> request = AsyncRequestImpl<IDBKeyData, IDBKeyData, PassRefPtr<SharedBuffer>, uint32_t, String>::create([this, callback](const IDBKeyData& key, const IDBKeyData& primaryKey, PassRefPtr<SharedBuffer> value, uint32_t errorCode, const String& errorMessage) {
- callback(key, primaryKey, value, errorCode, errorMessage);
- }, [this, callback] {
- callback(nullptr, nullptr, nullptr, INVALID_STATE_ERR, "Unable to advance cursor in database");
- });
-
- uint64_t requestID = request->requestID();
- m_pendingDatabaseTasks.add(requestID, request.release());
-
- postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::advanceCursorInBackingStore, requestID, cursorIdentifier, count));
-}
-
-void UniqueIDBDatabase::cursorIterate(const IDBIdentifier& cursorIdentifier, const IDBKeyData& key, std::function<void (const IDBKeyData&, const IDBKeyData&, PassRefPtr<SharedBuffer>, uint32_t, const String&)> callback)
-{
- ASSERT(RunLoop::isMain());
-
- if (!m_acceptingNewRequests) {
- callback(nullptr, nullptr, nullptr, INVALID_STATE_ERR, "Unable to iterate cursor in database because it has shut down");
- return;
- }
-
- RefPtr<AsyncRequest> request = AsyncRequestImpl<IDBKeyData, IDBKeyData, PassRefPtr<SharedBuffer>, uint32_t, String>::create([this, callback](const IDBKeyData& key, const IDBKeyData& primaryKey, PassRefPtr<SharedBuffer> value, uint32_t errorCode, const String& errorMessage) {
- callback(key, primaryKey, value, errorCode, errorMessage);
- }, [this, callback] {
- callback(nullptr, nullptr, nullptr, INVALID_STATE_ERR, "Unable to iterate cursor in database");
- });
-
- uint64_t requestID = request->requestID();
- m_pendingDatabaseTasks.add(requestID, request.release());
-
- postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::iterateCursorInBackingStore, requestID, cursorIdentifier, key));
-}
-
-void UniqueIDBDatabase::count(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, const IDBKeyRangeData& keyRangeData, std::function<void (int64_t, uint32_t, const String&)> callback)
-{
- ASSERT(RunLoop::isMain());
-
- if (!m_acceptingNewRequests) {
- callback(0, INVALID_STATE_ERR, "Unable to get count from database because it has shut down");
- return;
- }
-
- RefPtr<AsyncRequest> request = AsyncRequestImpl<int64_t, uint32_t, String>::create([this, callback](int64_t count, uint32_t errorCode, const String& errorMessage) {
- callback(count, errorCode, errorMessage);
- }, [this, callback] {
- callback(0, INVALID_STATE_ERR, "Unable to get count from database");
- });
-
- uint64_t requestID = request->requestID();
- m_pendingDatabaseTasks.add(requestID, request.release());
-
- postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::countInBackingStore, requestID, transactionIdentifier, objectStoreID, indexID, keyRangeData));
-}
-
-void UniqueIDBDatabase::deleteRange(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const IDBKeyRangeData& keyRangeData, std::function<void (uint32_t, const String&)> callback)
-{
- ASSERT(RunLoop::isMain());
-
- if (!m_acceptingNewRequests) {
- callback(INVALID_STATE_ERR, "Unable to deleteRange from database because it has shut down");
- return;
- }
-
- RefPtr<AsyncRequest> request = AsyncRequestImpl<uint32_t, String>::create([callback](uint32_t errorCode, const String& errorMessage) {
- callback(errorCode, errorMessage);
- }, [callback] {
- callback(INVALID_STATE_ERR, "Unable to deleteRange from database");
- });
-
- uint64_t requestID = request->requestID();
- m_pendingDatabaseTasks.add(requestID, request.release());
-
- postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::deleteRangeInBackingStore, requestID, transactionIdentifier, objectStoreID, keyRangeData));
-}
-
-void UniqueIDBDatabase::openBackingStoreTransaction(const IDBIdentifier& transactionIdentifier, const Vector<int64_t>& objectStoreIDs, IndexedDB::TransactionMode mode)
-{
- ASSERT(!RunLoop::isMain());
- ASSERT(m_backingStore);
-
- bool success = m_backingStore->establishTransaction(transactionIdentifier, objectStoreIDs, mode);
-
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didEstablishTransaction, transactionIdentifier, success));
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didCompleteTransactionOperation, transactionIdentifier, success));
-}
-
-void UniqueIDBDatabase::beginBackingStoreTransaction(const IDBIdentifier& transactionIdentifier)
-{
- ASSERT(!RunLoop::isMain());
- ASSERT(m_backingStore);
-
- bool success = m_backingStore->beginTransaction(transactionIdentifier);
-
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didCompleteTransactionOperation, transactionIdentifier, success));
-}
-
-void UniqueIDBDatabase::commitBackingStoreTransaction(const IDBIdentifier& transactionIdentifier)
-{
- ASSERT(!RunLoop::isMain());
- ASSERT(m_backingStore);
-
- bool success = m_backingStore->commitTransaction(transactionIdentifier);
-
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didCompleteTransactionOperation, transactionIdentifier, success));
-}
-
-void UniqueIDBDatabase::resetBackingStoreTransaction(const IDBIdentifier& transactionIdentifier)
-{
- ASSERT(!RunLoop::isMain());
- ASSERT(m_backingStore);
-
- bool success = m_backingStore->resetTransaction(transactionIdentifier);
-
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didResetTransaction, transactionIdentifier, success));
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didCompleteTransactionOperation, transactionIdentifier, success));
-}
-
-void UniqueIDBDatabase::rollbackBackingStoreTransaction(const IDBIdentifier& transactionIdentifier)
-{
- ASSERT(!RunLoop::isMain());
- ASSERT(m_backingStore);
-
- bool success = m_backingStore->rollbackTransaction(transactionIdentifier);
-
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didCompleteTransactionOperation, transactionIdentifier, success));
-}
-
-void UniqueIDBDatabase::changeDatabaseVersionInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, uint64_t newVersion)
-{
- ASSERT(!RunLoop::isMain());
- ASSERT(m_backingStore);
-
- bool success = m_backingStore->changeDatabaseVersion(transactionIdentifier, newVersion);
-
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didChangeDatabaseVersion, requestID, success));
-}
-
-void UniqueIDBDatabase::createObjectStoreInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, const IDBObjectStoreMetadata& metadata)
-{
- ASSERT(!RunLoop::isMain());
- ASSERT(m_backingStore);
-
- bool success = m_backingStore->createObjectStore(transactionIdentifier, metadata);
-
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didCreateObjectStore, requestID, success));
-}
-
-void UniqueIDBDatabase::deleteObjectStoreInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID)
-{
- ASSERT(!RunLoop::isMain());
- ASSERT(m_backingStore);
-
- bool success = m_backingStore->deleteObjectStore(transactionIdentifier, objectStoreID);
-
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didDeleteObjectStore, requestID, success));
-}
-
-void UniqueIDBDatabase::clearObjectStoreInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID)
-{
- ASSERT(!RunLoop::isMain());
- ASSERT(m_backingStore);
-
- bool success = m_backingStore->clearObjectStore(transactionIdentifier, objectStoreID);
-
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didClearObjectStore, requestID, success));
-}
-
-void UniqueIDBDatabase::createIndexInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const IDBIndexMetadata& metadata)
-{
- ASSERT(!RunLoop::isMain());
- ASSERT(m_backingStore);
-
- bool success = m_backingStore->createIndex(transactionIdentifier, objectStoreID, metadata);
-
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didCreateIndex, requestID, success));
-}
-
-void UniqueIDBDatabase::deleteIndexInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID)
-{
- ASSERT(!RunLoop::isMain());
- ASSERT(m_backingStore);
-
- bool success = m_backingStore->deleteIndex(transactionIdentifier, objectStoreID, indexID);
-
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didDeleteIndex, requestID, success));
-}
-
-void UniqueIDBDatabase::putRecordInBackingStore(uint64_t requestID, const IDBIdentifier& transaction, const IDBObjectStoreMetadata& objectStoreMetadata, const IDBKeyData& inputKeyData, const Vector<uint8_t>& value, int64_t putMode, const Vector<int64_t>& indexIDs, const Vector<Vector<IDBKeyData>>& indexKeys)
-{
- ASSERT(!RunLoop::isMain());
- ASSERT(m_backingStore);
-
- bool keyWasGenerated = false;
- IDBKeyData key;
- int64_t keyNumber = 0;
-
- if (putMode != IDBDatabaseBackend::CursorUpdate && objectStoreMetadata.autoIncrement && inputKeyData.isNull()) {
- if (!m_backingStore->generateKeyNumber(transaction, objectStoreMetadata.id, keyNumber)) {
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didPutRecordInBackingStore, requestID, IDBKeyData(), IDBDatabaseException::UnknownError, ASCIILiteral("Internal backing store error checking for key existence")));
- return;
- }
- key.setNumberValue(keyNumber);
- keyWasGenerated = true;
- } else
- key = inputKeyData;
-
- if (putMode == IDBDatabaseBackend::AddOnly) {
- bool keyExists;
- if (!m_backingStore->keyExistsInObjectStore(transaction, objectStoreMetadata.id, key, keyExists)) {
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didPutRecordInBackingStore, requestID, IDBKeyData(), IDBDatabaseException::UnknownError, ASCIILiteral("Internal backing store error checking for key existence")));
- return;
- }
- if (keyExists) {
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didPutRecordInBackingStore, requestID, IDBKeyData(), IDBDatabaseException::ConstraintError, ASCIILiteral("Key already exists in the object store")));
- return;
- }
- }
-
- // The spec says that even if we're about to overwrite the record, perform the steps to delete it first.
- // This is important because formally deleting it from from the object store also removes it from the appropriate indexes.
- if (!m_backingStore->deleteRecord(transaction, objectStoreMetadata.id, key)) {
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didPutRecordInBackingStore, requestID, IDBKeyData(), IDBDatabaseException::UnknownError, ASCIILiteral("Replacing an existing key in backing store, unable to delete previous record.")));
- return;
- }
-
- if (!m_backingStore->putRecord(transaction, objectStoreMetadata.id, key, value.data(), value.size())) {
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didPutRecordInBackingStore, requestID, IDBKeyData(), IDBDatabaseException::UnknownError, ASCIILiteral("Internal backing store error putting a record")));
- return;
- }
-
- ASSERT(indexIDs.size() == indexKeys.size());
- for (size_t i = 0; i < indexIDs.size(); ++i) {
- for (size_t j = 0; j < indexKeys[i].size(); ++j) {
- if (!m_backingStore->putIndexRecord(transaction, objectStoreMetadata.id, indexIDs[i], key, indexKeys[i][j])) {
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didPutRecordInBackingStore, requestID, IDBKeyData(), IDBDatabaseException::UnknownError, ASCIILiteral("Internal backing store error writing index key")));
- return;
- }
- }
- }
-
- m_backingStore->notifyCursorsOfChanges(transaction, objectStoreMetadata.id);
-
- if (putMode != IDBDatabaseBackend::CursorUpdate && objectStoreMetadata.autoIncrement && key.type() == KeyType::Number) {
- if (!m_backingStore->updateKeyGeneratorNumber(transaction, objectStoreMetadata.id, keyNumber, keyWasGenerated)) {
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didPutRecordInBackingStore, requestID, IDBKeyData(), IDBDatabaseException::UnknownError, ASCIILiteral("Internal backing store error updating key generator")));
- return;
- }
- }
-
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didPutRecordInBackingStore, requestID, key, 0, String(StringImpl::empty())));
-}
-
-void UniqueIDBDatabase::didPutRecordInBackingStore(uint64_t requestID, const IDBKeyData& keyData, uint32_t errorCode, const String& errorMessage)
-{
- m_pendingDatabaseTasks.take(requestID).get().completeRequest(keyData, errorCode, errorMessage);
-}
-
-void UniqueIDBDatabase::getRecordFromBackingStore(uint64_t requestID, const IDBIdentifier& transaction, const IDBObjectStoreMetadata& objectStoreMetadata, int64_t indexID, const IDBKeyRangeData& keyRangeData, IndexedDB::CursorType cursorType)
-{
- ASSERT(!RunLoop::isMain());
- ASSERT(m_backingStore);
-
- RefPtr<IDBKeyRange> keyRange = keyRangeData.maybeCreateIDBKeyRange();
- ASSERT(keyRange);
- if (!keyRange) {
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didGetRecordFromBackingStore, requestID, IDBGetResult(), IDBDatabaseException::UnknownError, ASCIILiteral("Invalid IDBKeyRange requested from backing store")));
- return;
- }
-
- if (indexID == IDBIndexMetadata::InvalidId) {
- // IDBObjectStore get record
- RefPtr<SharedBuffer> result;
-
- if (keyRange->isOnlyKey()) {
- if (!m_backingStore->getKeyRecordFromObjectStore(transaction, objectStoreMetadata.id, *keyRange->lower(), result))
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didGetRecordFromBackingStore, requestID, IDBGetResult(), IDBDatabaseException::UnknownError, ASCIILiteral("Failed to get key record from object store in backing store")));
- else {
- IDBGetResult getResult = result ? IDBGetResult(result.release(), keyRange->lower(), objectStoreMetadata.keyPath) : IDBGetResult();
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didGetRecordFromBackingStore, requestID, getResult, 0, String(StringImpl::empty())));
- }
-
- return;
- }
-
- RefPtr<IDBKey> resultKey;
-
- if (!m_backingStore->getKeyRangeRecordFromObjectStore(transaction, objectStoreMetadata.id, *keyRange, result, resultKey))
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didGetRecordFromBackingStore, requestID, IDBGetResult(), IDBDatabaseException::UnknownError, ASCIILiteral("Failed to get key range record from object store in backing store")));
- else {
- IDBGetResult getResult = result ? IDBGetResult(result.release(), resultKey.release(), objectStoreMetadata.keyPath) : IDBGetResult();
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didGetRecordFromBackingStore, requestID, getResult, 0, String(StringImpl::empty())));
- }
-
- return;
- }
-
- // IDBIndex get record
-
- IDBGetResult result;
- if (!m_backingStore->getIndexRecord(transaction, objectStoreMetadata.id, indexID, keyRangeData, cursorType, result)) {
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didGetRecordFromBackingStore, requestID, IDBGetResult(), IDBDatabaseException::UnknownError, ASCIILiteral("Failed to get index record from backing store")));
- return;
- }
-
- // We must return a key path to know how to inject the result key into the result value object.
- result.setKeyPath(objectStoreMetadata.keyPath);
-
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didGetRecordFromBackingStore, requestID, result, 0, String(StringImpl::empty())));
-}
-
-void UniqueIDBDatabase::didGetRecordFromBackingStore(uint64_t requestID, const IDBGetResult& result, uint32_t errorCode, const String& errorMessage)
-{
- m_pendingDatabaseTasks.take(requestID).get().completeRequest(result, errorCode, errorMessage);
-}
-
-void UniqueIDBDatabase::openCursorInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, IndexedDB::CursorDirection cursorDirection, IndexedDB::CursorType cursorType, IDBDatabaseBackend::TaskType taskType, const IDBKeyRangeData& keyRange)
-{
- ASSERT(!RunLoop::isMain());
- ASSERT(m_backingStore);
-
- int64_t cursorID = 0;
- IDBKeyData key;
- IDBKeyData primaryKey;
- Vector<uint8_t> valueBuffer;
- int32_t errorCode = 0;
- String errorMessage;
- bool success = m_backingStore->openCursor(transactionIdentifier, objectStoreID, indexID, cursorDirection, cursorType, taskType, keyRange, cursorID, key, primaryKey, valueBuffer);
-
- if (!success) {
- errorCode = IDBDatabaseException::UnknownError;
- errorMessage = ASCIILiteral("Unknown error opening cursor in backing store");
- }
-
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didOpenCursorInBackingStore, requestID, cursorID, key, primaryKey, valueBuffer, errorCode, errorMessage));
-}
-
-void UniqueIDBDatabase::didOpenCursorInBackingStore(uint64_t requestID, int64_t cursorID, const IDBKeyData& key, const IDBKeyData& primaryKey, const Vector<uint8_t>& valueBuffer, uint32_t errorCode, const String& errorMessage)
-{
- m_pendingDatabaseTasks.take(requestID).get().completeRequest(cursorID, key, primaryKey, SharedBuffer::create(valueBuffer.data(), valueBuffer.size()), errorCode, errorMessage);
-}
-
-void UniqueIDBDatabase::advanceCursorInBackingStore(uint64_t requestID, const IDBIdentifier& cursorIdentifier, uint64_t count)
-{
- IDBKeyData key;
- IDBKeyData primaryKey;
- Vector<uint8_t> valueBuffer;
- int32_t errorCode = 0;
- String errorMessage;
- bool success = m_backingStore->advanceCursor(cursorIdentifier, count, key, primaryKey, valueBuffer);
-
- if (!success) {
- errorCode = IDBDatabaseException::UnknownError;
- errorMessage = ASCIILiteral("Unknown error advancing cursor in backing store");
- }
-
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didAdvanceCursorInBackingStore, requestID, key, primaryKey, valueBuffer, errorCode, errorMessage));
-}
-
-void UniqueIDBDatabase::didAdvanceCursorInBackingStore(uint64_t requestID, const IDBKeyData& key, const IDBKeyData& primaryKey, const Vector<uint8_t>& valueBuffer, uint32_t errorCode, const String& errorMessage)
-{
- m_pendingDatabaseTasks.take(requestID).get().completeRequest(key, primaryKey, SharedBuffer::create(valueBuffer.data(), valueBuffer.size()), errorCode, errorMessage);
-}
-
-void UniqueIDBDatabase::iterateCursorInBackingStore(uint64_t requestID, const IDBIdentifier& cursorIdentifier, const IDBKeyData& iterateKey)
-{
- IDBKeyData key;
- IDBKeyData primaryKey;
- Vector<uint8_t> valueBuffer;
- int32_t errorCode = 0;
- String errorMessage;
- bool success = m_backingStore->iterateCursor(cursorIdentifier, iterateKey, key, primaryKey, valueBuffer);
-
- if (!success) {
- errorCode = IDBDatabaseException::UnknownError;
- errorMessage = ASCIILiteral("Unknown error iterating cursor in backing store");
- }
-
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didIterateCursorInBackingStore, requestID, key, primaryKey, valueBuffer, errorCode, errorMessage));
-}
-
-void UniqueIDBDatabase::didIterateCursorInBackingStore(uint64_t requestID, const IDBKeyData& key, const IDBKeyData& primaryKey, const Vector<uint8_t>& valueBuffer, uint32_t errorCode, const String& errorMessage)
-{
- m_pendingDatabaseTasks.take(requestID).get().completeRequest(key, primaryKey, SharedBuffer::create(valueBuffer.data(), valueBuffer.size()), errorCode, errorMessage);
-}
-
-void UniqueIDBDatabase::countInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, const IDBKeyRangeData& keyRangeData)
-{
- int64_t count;
-
- if (!m_backingStore->count(transactionIdentifier, objectStoreID, indexID, keyRangeData, count)) {
- LOG_ERROR("Failed to get count from backing store.");
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didCountInBackingStore, requestID, 0, IDBDatabaseException::UnknownError, ASCIILiteral("Failed to get count from backing store")));
-
- return;
- }
-
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didCountInBackingStore, requestID, count, 0, String(StringImpl::empty())));
-}
-
-void UniqueIDBDatabase::didCountInBackingStore(uint64_t requestID, int64_t count, uint32_t errorCode, const String& errorMessage)
-{
- m_pendingDatabaseTasks.take(requestID).get().completeRequest(count, errorCode, errorMessage);
-}
-
-void UniqueIDBDatabase::deleteRangeInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const IDBKeyRangeData& keyRangeData)
-{
- if (!m_backingStore->deleteRange(transactionIdentifier, objectStoreID, keyRangeData)) {
- LOG_ERROR("Failed to delete range from backing store.");
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didDeleteRangeInBackingStore, requestID, IDBDatabaseException::UnknownError, ASCIILiteral("Failed to get count from backing store")));
-
- return;
- }
-
- m_backingStore->notifyCursorsOfChanges(transactionIdentifier, objectStoreID);
-
- postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didDeleteRangeInBackingStore, requestID, 0, String(StringImpl::empty())));
-}
-
-void UniqueIDBDatabase::didDeleteRangeInBackingStore(uint64_t requestID, uint32_t errorCode, const String& errorMessage)
-{
- m_pendingDatabaseTasks.take(requestID).get().completeRequest(errorCode, errorMessage);
-}
-
-void UniqueIDBDatabase::didEstablishTransaction(const IDBIdentifier& transactionIdentifier, bool success)
-{
- ASSERT(RunLoop::isMain());
- if (!success)
- return;
-
- auto transactions = m_establishedTransactions.add(&transactionIdentifier.connection(), HashSet<IDBIdentifier>());
- transactions.iterator->value.add(transactionIdentifier);
-}
-
-void UniqueIDBDatabase::didResetTransaction(const IDBIdentifier& transactionIdentifier, bool success)
-{
- ASSERT(RunLoop::isMain());
- if (!success)
- return;
-
- auto transactions = m_establishedTransactions.find(&transactionIdentifier.connection());
- if (transactions != m_establishedTransactions.end())
- transactions.get()->value.remove(transactionIdentifier);
-}
-
-void UniqueIDBDatabase::resetAllTransactions(const DatabaseProcessIDBConnection& connection)
-{
- ASSERT(RunLoop::isMain());
- auto transactions = m_establishedTransactions.find(&connection);
- if (transactions == m_establishedTransactions.end() || !m_acceptingNewRequests)
- return;
-
- for (auto& transactionIdentifier : transactions.get()->value) {
- m_pendingTransactionRollbacks.add(transactionIdentifier);
- if (!m_pendingTransactionRequests.contains(transactionIdentifier))
- finalizeRollback(transactionIdentifier);
- }
-}
-
-void UniqueIDBDatabase::finalizeRollback(const WebKit::IDBIdentifier& transactionId)
-{
- ASSERT(RunLoop::isMain());
- ASSERT(m_pendingTransactionRollbacks.contains(transactionId));
- ASSERT(!m_pendingTransactionRequests.contains(transactionId));
- rollbackTransaction(transactionId, [this, transactionId](bool) {
- ASSERT(RunLoop::isMain());
- if (m_pendingTransactionRequests.contains(transactionId))
- return;
-
- ASSERT(m_pendingTransactionRollbacks.contains(transactionId));
- m_pendingTransactionRollbacks.remove(transactionId);
- resetTransaction(transactionId, [this, transactionId](bool) {
- if (m_acceptingNewRequests && m_connections.isEmpty() && m_pendingTransactionRollbacks.isEmpty()) {
- shutdown(UniqueIDBDatabaseShutdownType::NormalShutdown);
- DatabaseProcess::singleton().removeUniqueIDBDatabase(*this);
- }
- });
- });
-}
-
-String UniqueIDBDatabase::absoluteDatabaseDirectory() const
-{
- ASSERT(RunLoop::isMain());
- return DatabaseProcess::singleton().absoluteIndexedDatabasePathFromDatabaseRelativePath(m_databaseRelativeDirectory);
-}
-
-void UniqueIDBDatabase::postMainThreadTask(std::unique_ptr<CrossThreadTask> task, DatabaseTaskType taskType)
-{
- ASSERT(!RunLoop::isMain());
-
- if (!m_acceptingNewRequests && taskType == DatabaseTaskType::Normal)
- return;
-
- LockHolder locker(m_mainThreadTaskMutex);
-
- m_mainThreadTasks.append(WTFMove(task));
-
- RefPtr<UniqueIDBDatabase> database(this);
- RunLoop::main().dispatch([database] {
- database->performNextMainThreadTask();
- });
-}
-
-bool UniqueIDBDatabase::performNextMainThreadTask()
-{
- ASSERT(RunLoop::isMain());
-
- bool moreTasks;
-
- std::unique_ptr<CrossThreadTask> task;
- {
- LockHolder locker(m_mainThreadTaskMutex);
-
- // This database might be shutting down, in which case the task queue might be empty.
- if (m_mainThreadTasks.isEmpty())
- return false;
-
- task = m_mainThreadTasks.takeFirst();
- moreTasks = !m_mainThreadTasks.isEmpty();
- }
-
- task->performTask();
-
- return moreTasks;
-}
-
-void UniqueIDBDatabase::postDatabaseTask(std::unique_ptr<CrossThreadTask> task, DatabaseTaskType taskType)
-{
- ASSERT(RunLoop::isMain());
-
- if (!m_acceptingNewRequests && taskType == DatabaseTaskType::Normal)
- return;
-
- LockHolder locker(m_databaseTaskMutex);
-
- m_databaseTasks.append(WTFMove(task));
-
- RefPtr<UniqueIDBDatabase> database(this);
- DatabaseProcess::singleton().queue().dispatch([database] {
- database->performNextDatabaseTask();
- });
-}
-
-void UniqueIDBDatabase::performNextDatabaseTask()
-{
- ASSERT(!RunLoop::isMain());
-
- // It is possible that this database might be shutting down on the main thread.
- // In this case, immediately after releasing m_databaseTaskMutex, this database might get deleted.
- // We take a ref() to make sure the database is still live while this last task is performed.
- RefPtr<UniqueIDBDatabase> protector(this);
-
- std::unique_ptr<CrossThreadTask> task;
- {
- LockHolder locker(m_databaseTaskMutex);
-
- // This database might be shutting down on the main thread, in which case the task queue might be empty.
- if (m_databaseTasks.isEmpty())
- return;
-
- task = m_databaseTasks.takeFirst();
- }
-
- task->performTask();
-}
-
-} // namespace WebKit
-
-#endif // ENABLE(INDEXED_DATABASE) && ENABLE(DATABASE_PROCESS)
</del></span></pre></div>
<a id="trunkSourceWebKit2DatabaseProcessIndexedDBUniqueIDBDatabaseh"></a>
<div class="delfile"><h4>Deleted: trunk/Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabase.h (196734 => 196735)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabase.h 2016-02-18 01:17:36 UTC (rev 196734)
+++ trunk/Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabase.h 2016-02-18 01:25:21 UTC (rev 196735)
</span><span class="lines">@@ -1,221 +0,0 @@
</span><del>-/*
- * Copyright (C) 2013 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. AND ITS CONTRIBUTORS ``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 ITS 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.
- */
-
-#ifndef UniqueIDBDatabase_h
-#define UniqueIDBDatabase_h
-
-#if ENABLE(INDEXED_DATABASE) && ENABLE(DATABASE_PROCESS)
-
-#include "AsyncRequest.h"
-#include "IDBIdentifier.h"
-#include "UniqueIDBDatabaseIdentifier.h"
-#include <WebCore/IDBDatabaseBackend.h>
-#include <WebCore/IndexedDB.h>
-#include <functional>
-#include <wtf/Deque.h>
-#include <wtf/HashSet.h>
-#include <wtf/PassRefPtr.h>
-#include <wtf/RefCounted.h>
-#include <wtf/text/WTFString.h>
-
-namespace IPC {
-class DataReference;
-}
-
-namespace WebCore {
-class CrossThreadTask;
-class IDBGetResult;
-class IDBKeyData;
-class SharedBuffer;
-
-struct IDBDatabaseMetadata;
-struct IDBKeyRangeData;
-struct SecurityOriginData;
-}
-
-namespace WebKit {
-
-class DatabaseProcessIDBConnection;
-class UniqueIDBDatabaseBackingStore;
-
-enum class UniqueIDBDatabaseShutdownType {
- NormalShutdown,
- DeleteShutdown
-};
-
-class UniqueIDBDatabase : public ThreadSafeRefCounted<UniqueIDBDatabase> {
-public:
- static Ref<UniqueIDBDatabase> create(const UniqueIDBDatabaseIdentifier& identifier)
- {
- return adoptRef(*new UniqueIDBDatabase(identifier));
- }
-
- ~UniqueIDBDatabase();
-
- static String calculateAbsoluteDatabaseFilename(const String& absoluteDatabaseDirectory);
-
- const UniqueIDBDatabaseIdentifier& identifier() const { return m_identifier; }
-
- void registerConnection(DatabaseProcessIDBConnection&);
- void unregisterConnection(DatabaseProcessIDBConnection&);
-
- void deleteDatabase(std::function<void (bool)> successCallback);
-
- void getOrEstablishIDBDatabaseMetadata(std::function<void (bool, const WebCore::IDBDatabaseMetadata&)> completionCallback);
-
- void openTransaction(const IDBIdentifier& transactionIdentifier, const Vector<int64_t>& objectStoreIDs, WebCore::IndexedDB::TransactionMode, std::function<void (bool)> successCallback);
- void beginTransaction(const IDBIdentifier& transactionIdentifier, std::function<void (bool)> successCallback);
- void commitTransaction(const IDBIdentifier& transactionIdentifier, std::function<void (bool)> successCallback);
- void resetTransaction(const IDBIdentifier& transactionIdentifier, std::function<void (bool)> successCallback);
- void rollbackTransaction(const IDBIdentifier& transactionIdentifier, std::function<void (bool)> successCallback);
-
- void changeDatabaseVersion(const IDBIdentifier& transactionIdentifier, uint64_t newVersion, std::function<void (bool)> successCallback);
- void createObjectStore(const IDBIdentifier& transactionIdentifier, const WebCore::IDBObjectStoreMetadata&, std::function<void (bool)> successCallback);
- void deleteObjectStore(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, std::function<void (bool)> successCallback);
- void clearObjectStore(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, std::function<void (bool)> successCallback);
- void createIndex(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const WebCore::IDBIndexMetadata&, std::function<void (bool)> successCallback);
- void deleteIndex(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, std::function<void (bool)> successCallback);
-
- void putRecord(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const WebCore::IDBKeyData&, const IPC::DataReference& value, int64_t putMode, const Vector<int64_t>& indexIDs, const Vector<Vector<WebCore::IDBKeyData>>& indexKeys, std::function<void (const WebCore::IDBKeyData&, uint32_t, const String&)> callback);
- void getRecord(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, const WebCore::IDBKeyRangeData&, WebCore::IndexedDB::CursorType, std::function<void (const WebCore::IDBGetResult&, uint32_t, const String&)> callback);
-
- void openCursor(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, WebCore::IndexedDB::CursorDirection, WebCore::IndexedDB::CursorType, WebCore::IDBDatabaseBackend::TaskType, const WebCore::IDBKeyRangeData&, std::function<void (int64_t, const WebCore::IDBKeyData&, const WebCore::IDBKeyData&, PassRefPtr<WebCore::SharedBuffer>, uint32_t, const String&)> callback);
- void cursorAdvance(const IDBIdentifier& cursorIdentifier, uint64_t count, std::function<void (const WebCore::IDBKeyData&, const WebCore::IDBKeyData&, PassRefPtr<WebCore::SharedBuffer>, uint32_t, const String&)> callback);
- void cursorIterate(const IDBIdentifier& cursorIdentifier, const WebCore::IDBKeyData&, std::function<void (const WebCore::IDBKeyData&, const WebCore::IDBKeyData&, PassRefPtr<WebCore::SharedBuffer>, uint32_t, const String&)> callback);
-
- void count(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, const WebCore::IDBKeyRangeData&, std::function<void (int64_t, uint32_t, const String&)> callback);
- void deleteRange(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const WebCore::IDBKeyRangeData&, std::function<void (uint32_t, const String&)> callback);
-
-private:
- UniqueIDBDatabase(const UniqueIDBDatabaseIdentifier&);
-
- UniqueIDBDatabaseIdentifier m_identifier;
-
- bool m_inMemory;
- String m_databaseRelativeDirectory;
-
- HashSet<RefPtr<DatabaseProcessIDBConnection>> m_connections;
- HashMap<uint64_t, RefPtr<AsyncRequest>> m_databaseRequests;
-
- String absoluteDatabaseDirectory() const;
-
- enum class DatabaseTaskType {
- Normal,
- Shutdown
- };
- void postDatabaseTask(std::unique_ptr<WebCore::CrossThreadTask>, DatabaseTaskType = DatabaseTaskType::Normal);
-
- void shutdown(UniqueIDBDatabaseShutdownType);
-
- // Method that attempts to make legal filenames from all legal database names
- String filenameForDatabaseName() const;
-
- // Returns a string that is appropriate for use as a unique filename
- String databaseFilenameIdentifier(const WebCore::SecurityOriginData&) const;
-
- // Returns true if this origin can use the same databases as the given origin.
- bool canShareDatabases(const WebCore::SecurityOriginData&, const WebCore::SecurityOriginData&) const;
-
- void postTransactionOperation(const IDBIdentifier& transactionIdentifier, std::unique_ptr<WebCore::CrossThreadTask>, std::function<void (bool)> successCallback);
-
- // To be called from the database workqueue thread only
- void performNextDatabaseTask();
- void postMainThreadTask(std::unique_ptr<WebCore::CrossThreadTask>, DatabaseTaskType = DatabaseTaskType::Normal);
- void openBackingStoreAndReadMetadata(const UniqueIDBDatabaseIdentifier&, const String& databaseDirectory);
- void openBackingStoreTransaction(const IDBIdentifier& transactionIdentifier, const Vector<int64_t>& objectStoreIDs, WebCore::IndexedDB::TransactionMode);
- void beginBackingStoreTransaction(const IDBIdentifier&);
- void commitBackingStoreTransaction(const IDBIdentifier&);
- void resetBackingStoreTransaction(const IDBIdentifier&);
- void rollbackBackingStoreTransaction(const IDBIdentifier&);
-
- void changeDatabaseVersionInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, uint64_t newVersion);
- void createObjectStoreInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, const WebCore::IDBObjectStoreMetadata&);
- void deleteObjectStoreInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID);
- void clearObjectStoreInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID);
-
- void createIndexInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const WebCore::IDBIndexMetadata&);
- void deleteIndexInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID);
-
- void putRecordInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, const WebCore::IDBObjectStoreMetadata&, const WebCore::IDBKeyData&, const Vector<uint8_t>& value, int64_t putMode, const Vector<int64_t>& indexIDs, const Vector<Vector<WebCore::IDBKeyData>>& indexKeys);
- void getRecordFromBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, const WebCore::IDBObjectStoreMetadata&, int64_t indexID, const WebCore::IDBKeyRangeData&, WebCore::IndexedDB::CursorType);
- void openCursorInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, WebCore::IndexedDB::CursorDirection, WebCore::IndexedDB::CursorType, WebCore::IDBDatabaseBackend::TaskType, const WebCore::IDBKeyRangeData&);
- void advanceCursorInBackingStore(uint64_t requestID, const IDBIdentifier& cursorIdentifier, uint64_t count);
- void iterateCursorInBackingStore(uint64_t requestID, const IDBIdentifier& cursorIdentifier, const WebCore::IDBKeyData&);
- void countInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, const WebCore::IDBKeyRangeData&);
- void deleteRangeInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const WebCore::IDBKeyRangeData&);
-
- void shutdownBackingStore(UniqueIDBDatabaseShutdownType, const String& databaseDirectory);
-
- // Callbacks from the database workqueue thread, to be performed on the main thread only
- bool performNextMainThreadTask();
- void didOpenBackingStoreAndReadMetadata(const WebCore::IDBDatabaseMetadata&, bool success);
- void didCompleteTransactionOperation(const IDBIdentifier& transactionIdentifier, bool success);
- void didChangeDatabaseVersion(uint64_t requestID, bool success);
- void didCreateObjectStore(uint64_t requestID, bool success);
- void didDeleteObjectStore(uint64_t requestID, bool success);
- void didClearObjectStore(uint64_t requestID, bool success);
- void didCreateIndex(uint64_t requestID, bool success);
- void didDeleteIndex(uint64_t requestID, bool success);
- void didPutRecordInBackingStore(uint64_t requestID, const WebCore::IDBKeyData&, uint32_t errorCode, const String& errorMessage);
- void didGetRecordFromBackingStore(uint64_t requestID, const WebCore::IDBGetResult&, uint32_t errorCode, const String& errorMessage);
- void didOpenCursorInBackingStore(uint64_t requestID, int64_t cursorID, const WebCore::IDBKeyData&, const WebCore::IDBKeyData&, const Vector<uint8_t>&, uint32_t errorCode, const String& errorMessage);
- void didAdvanceCursorInBackingStore(uint64_t requestID, const WebCore::IDBKeyData&, const WebCore::IDBKeyData&, const Vector<uint8_t>&, uint32_t errorCode, const String& errorMessage);
- void didIterateCursorInBackingStore(uint64_t requestID, const WebCore::IDBKeyData&, const WebCore::IDBKeyData&, const Vector<uint8_t>&, uint32_t errorCode, const String& errorMessage);
- void didCountInBackingStore(uint64_t requestID, int64_t count, uint32_t errorCode, const String& errorMessage);
- void didDeleteRangeInBackingStore(uint64_t requestID, uint32_t errorCode, const String& errorMessage);
-
- void didShutdownBackingStore(UniqueIDBDatabaseShutdownType);
- void didCompleteBoolRequest(uint64_t requestID, bool success);
-
- void didEstablishTransaction(const IDBIdentifier& transactionIdentifier, bool success);
- void didResetTransaction(const IDBIdentifier& transactionIdentifier, bool success);
- void resetAllTransactions(const DatabaseProcessIDBConnection&);
- void finalizeRollback(const IDBIdentifier& transactionId);
-
- bool m_acceptingNewRequests;
-
- HashMap<const DatabaseProcessIDBConnection*, HashSet<IDBIdentifier>> m_establishedTransactions;
- Deque<RefPtr<AsyncRequest>> m_pendingMetadataRequests;
- HashMap<IDBIdentifier, RefPtr<AsyncRequest>> m_pendingTransactionRequests;
- HashSet<IDBIdentifier> m_pendingTransactionRollbacks;
- AsyncRequestMap m_pendingDatabaseTasks;
- RefPtr<AsyncRequest> m_pendingShutdownTask;
-
- std::unique_ptr<WebCore::IDBDatabaseMetadata> m_metadata;
- bool m_didGetMetadataFromBackingStore;
-
- RefPtr<UniqueIDBDatabaseBackingStore> m_backingStore;
-
- Deque<std::unique_ptr<WebCore::CrossThreadTask>> m_databaseTasks;
- Lock m_databaseTaskMutex;
-
- Deque<std::unique_ptr<WebCore::CrossThreadTask>> m_mainThreadTasks;
- Lock m_mainThreadTaskMutex;
-};
-
-} // namespace WebKit
-
-#endif // ENABLE(INDEXED_DATABASE) && ENABLE(DATABASE_PROCESS)
-#endif // UniqueIDBDatabase_h
</del></span></pre></div>
<a id="trunkSourceWebKit2DatabaseProcessIndexedDBUniqueIDBDatabaseIdentifiercpp"></a>
<div class="delfile"><h4>Deleted: trunk/Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabaseIdentifier.cpp (196734 => 196735)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabaseIdentifier.cpp 2016-02-18 01:17:36 UTC (rev 196734)
+++ trunk/Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabaseIdentifier.cpp 2016-02-18 01:25:21 UTC (rev 196735)
</span><span class="lines">@@ -1,101 +0,0 @@
</span><del>-/*
- * Copyright (C) 2013 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. AND ITS CONTRIBUTORS ``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 ITS 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 "UniqueIDBDatabaseIdentifier.h"
-
-#if ENABLE(INDEXED_DATABASE) && ENABLE(DATABASE_PROCESS)
-
-#include <wtf/text/StringBuilder.h>
-
-namespace WebKit {
-
-UniqueIDBDatabaseIdentifier::UniqueIDBDatabaseIdentifier()
-{
-}
-
-UniqueIDBDatabaseIdentifier::UniqueIDBDatabaseIdentifier(const String& databaseName, const WebCore::SecurityOriginData& openingOrigin, const WebCore::SecurityOriginData& mainFrameOrigin)
- : m_databaseName(databaseName)
- , m_openingOrigin(openingOrigin)
- , m_mainFrameOrigin(mainFrameOrigin)
-{
- // While it is valid to have an empty database name, it is not valid to have a null one.
- ASSERT(!m_databaseName.isNull());
-}
-
-UniqueIDBDatabaseIdentifier::UniqueIDBDatabaseIdentifier(WTF::HashTableDeletedValueType)
- : m_databaseName(WTF::HashTableDeletedValue)
-{
-}
-
-bool UniqueIDBDatabaseIdentifier::isHashTableDeletedValue() const
-{
- return m_databaseName.isHashTableDeletedValue();
-}
-
-unsigned UniqueIDBDatabaseIdentifier::hash() const
-{
- unsigned hashCodes[7] = {
- m_databaseName.impl() ? m_databaseName.impl()->hash() : 0,
- m_openingOrigin.protocol.impl() ? m_openingOrigin.protocol.impl()->hash() : 0,
- m_openingOrigin.host.impl() ? m_openingOrigin.host.impl()->hash() : 0,
- static_cast<unsigned>(m_openingOrigin.port),
- m_mainFrameOrigin.protocol.impl() ? m_mainFrameOrigin.protocol.impl()->hash() : 0,
- m_mainFrameOrigin.host.impl() ? m_mainFrameOrigin.host.impl()->hash() : 0,
- static_cast<unsigned>(m_mainFrameOrigin.port)
- };
- return StringHasher::hashMemory<sizeof(hashCodes)>(hashCodes);
-}
-
-bool UniqueIDBDatabaseIdentifier::isNull() const
-{
- // Only a default constructed UniqueIDBDatabaseIdentifier can have a null database name.
- return m_databaseName.isNull();
-}
-
-UniqueIDBDatabaseIdentifier UniqueIDBDatabaseIdentifier::isolatedCopy() const
-{
- UniqueIDBDatabaseIdentifier result;
-
- result.m_databaseName = m_databaseName.isolatedCopy();
- result.m_openingOrigin = m_openingOrigin.isolatedCopy();
- result.m_mainFrameOrigin = m_mainFrameOrigin.isolatedCopy();
-
- return result;
-}
-
-bool operator==(const UniqueIDBDatabaseIdentifier& a, const UniqueIDBDatabaseIdentifier& b)
-{
- if (&a == &b)
- return true;
-
- return a.databaseName() == b.databaseName()
- && a.openingOrigin() == b.openingOrigin()
- && a.mainFrameOrigin() == b.mainFrameOrigin();
-}
-
-} // namespace WebKit
-
-#endif // ENABLE(INDEXED_DATABASE) && ENABLE(DATABASE_PROCESS)
</del></span></pre></div>
<a id="trunkSourceWebKit2DatabaseProcessIndexedDBUniqueIDBDatabaseIdentifierh"></a>
<div class="delfile"><h4>Deleted: trunk/Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabaseIdentifier.h (196734 => 196735)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabaseIdentifier.h 2016-02-18 01:17:36 UTC (rev 196734)
+++ trunk/Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabaseIdentifier.h 2016-02-18 01:25:21 UTC (rev 196735)
</span><span class="lines">@@ -1,86 +0,0 @@
</span><del>-/*
- * Copyright (C) 2013 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. AND ITS CONTRIBUTORS ``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 ITS 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.
- */
-
-#ifndef UniqueIDBDatabaseIdentifier_h
-#define UniqueIDBDatabaseIdentifier_h
-
-#if ENABLE(INDEXED_DATABASE) && ENABLE(DATABASE_PROCESS)
-
-#include <WebCore/SecurityOriginData.h>
-#include <wtf/PassRefPtr.h>
-#include <wtf/RefCounted.h>
-#include <wtf/text/WTFString.h>
-
-namespace WebKit {
-
-class UniqueIDBDatabaseIdentifier {
-public:
- UniqueIDBDatabaseIdentifier();
- UniqueIDBDatabaseIdentifier(const String& databaseName, const WebCore::SecurityOriginData& openingOrigin, const WebCore::SecurityOriginData& mainFrameOrigin);
-
- bool isNull() const;
-
- const String& databaseName() const { return m_databaseName; }
- const WebCore::SecurityOriginData& openingOrigin() const { return m_openingOrigin; }
- const WebCore::SecurityOriginData& mainFrameOrigin() const { return m_mainFrameOrigin; }
-
- UniqueIDBDatabaseIdentifier(WTF::HashTableDeletedValueType);
- bool isHashTableDeletedValue() const;
- unsigned hash() const;
-
- UniqueIDBDatabaseIdentifier isolatedCopy() const;
-
-private:
- String m_databaseName;
- WebCore::SecurityOriginData m_openingOrigin;
- WebCore::SecurityOriginData m_mainFrameOrigin;
-};
-
-bool operator==(const UniqueIDBDatabaseIdentifier&, const UniqueIDBDatabaseIdentifier&);
-
-struct UniqueIDBDatabaseIdentifierHash {
- static unsigned hash(const UniqueIDBDatabaseIdentifier& identifier) { return identifier.hash(); }
- static bool equal(const UniqueIDBDatabaseIdentifier& a, const UniqueIDBDatabaseIdentifier& b) { return a == b; }
- static const bool safeToCompareToEmptyOrDeleted = false;
-};
-
-struct UniqueIDBDatabaseIdentifierHashTraits : WTF::SimpleClassHashTraits<UniqueIDBDatabaseIdentifier> {
- static const bool hasIsEmptyValueFunction = true;
- static bool isEmptyValue(const UniqueIDBDatabaseIdentifier& info) { return info.isNull(); }
-};
-
-} // namespace WebKit
-
-namespace WTF {
-
-template<> struct HashTraits<WebKit::UniqueIDBDatabaseIdentifier> : WebKit::UniqueIDBDatabaseIdentifierHashTraits { };
-template<> struct DefaultHash<WebKit::UniqueIDBDatabaseIdentifier> {
- typedef WebKit::UniqueIDBDatabaseIdentifierHash Hash;
-};
-
-} // namespaec WTF
-
-#endif // ENABLE(INDEXED_DATABASE) && ENABLE(DATABASE_PROCESS)
-#endif // UniqueIDBDatabaseIdentifier_h
</del></span></pre></div>
<a id="trunkSourceWebKit2DatabaseProcessIndexedDBsqliteUniqueIDBDatabaseBackingStoreSQLitecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebKit2/DatabaseProcess/IndexedDB/sqlite/UniqueIDBDatabaseBackingStoreSQLite.cpp (196734 => 196735)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit2/DatabaseProcess/IndexedDB/sqlite/UniqueIDBDatabaseBackingStoreSQLite.cpp 2016-02-18 01:17:36 UTC (rev 196734)
+++ trunk/Source/WebKit2/DatabaseProcess/IndexedDB/sqlite/UniqueIDBDatabaseBackingStoreSQLite.cpp 2016-02-18 01:25:21 UTC (rev 196735)
</span><span class="lines">@@ -96,7 +96,7 @@
</span><span class="cx"> return ++databaseID;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-UniqueIDBDatabaseBackingStoreSQLite::UniqueIDBDatabaseBackingStoreSQLite(const UniqueIDBDatabaseIdentifier& identifier, const String& databaseDirectory)
</del><ins>+UniqueIDBDatabaseBackingStoreSQLite::UniqueIDBDatabaseBackingStoreSQLite(const LegacyUniqueIDBDatabaseIdentifier& identifier, const String& databaseDirectory)
</ins><span class="cx"> : m_identifier(identifier)
</span><span class="cx"> , m_absoluteDatabaseDirectory(databaseDirectory)
</span><span class="cx"> {
</span><span class="lines">@@ -427,7 +427,7 @@
</span><span class="cx"> {
</span><span class="cx"> ASSERT(!RunLoop::isMain());
</span><span class="cx">
</span><del>- String dbFilename = UniqueIDBDatabase::calculateAbsoluteDatabaseFilename(m_absoluteDatabaseDirectory);
</del><ins>+ String dbFilename = LegacyUniqueIDBDatabase::calculateAbsoluteDatabaseFilename(m_absoluteDatabaseDirectory);
</ins><span class="cx">
</span><span class="cx"> m_sqliteDB = openSQLiteDatabaseAtPath(dbFilename);
</span><span class="cx"> if (!m_sqliteDB)
</span></span></pre></div>
<a id="trunkSourceWebKit2DatabaseProcessIndexedDBsqliteUniqueIDBDatabaseBackingStoreSQLiteh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebKit2/DatabaseProcess/IndexedDB/sqlite/UniqueIDBDatabaseBackingStoreSQLite.h (196734 => 196735)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit2/DatabaseProcess/IndexedDB/sqlite/UniqueIDBDatabaseBackingStoreSQLite.h 2016-02-18 01:17:36 UTC (rev 196734)
+++ trunk/Source/WebKit2/DatabaseProcess/IndexedDB/sqlite/UniqueIDBDatabaseBackingStoreSQLite.h 2016-02-18 01:25:21 UTC (rev 196735)
</span><span class="lines">@@ -28,7 +28,7 @@
</span><span class="cx">
</span><span class="cx"> #if ENABLE(INDEXED_DATABASE) && ENABLE(DATABASE_PROCESS)
</span><span class="cx">
</span><del>-#include "UniqueIDBDatabase.h"
</del><ins>+#include "LegacyUniqueIDBDatabase.h"
</ins><span class="cx"> #include "UniqueIDBDatabaseBackingStore.h"
</span><span class="cx"> #include <JavaScriptCore/Strong.h>
</span><span class="cx"> #include <wtf/PassRefPtr.h>
</span><span class="lines">@@ -51,7 +51,7 @@
</span><span class="cx">
</span><span class="cx"> class UniqueIDBDatabaseBackingStoreSQLite final : public UniqueIDBDatabaseBackingStore {
</span><span class="cx"> public:
</span><del>- static Ref<UniqueIDBDatabaseBackingStore> create(const UniqueIDBDatabaseIdentifier& identifier, const String& databaseDirectory)
</del><ins>+ static Ref<UniqueIDBDatabaseBackingStore> create(const LegacyUniqueIDBDatabaseIdentifier& identifier, const String& databaseDirectory)
</ins><span class="cx"> {
</span><span class="cx"> return adoptRef(*new UniqueIDBDatabaseBackingStoreSQLite(identifier, databaseDirectory));
</span><span class="cx"> }
</span><span class="lines">@@ -95,7 +95,7 @@
</span><span class="cx"> void unregisterCursor(SQLiteIDBCursor*);
</span><span class="cx">
</span><span class="cx"> private:
</span><del>- UniqueIDBDatabaseBackingStoreSQLite(const UniqueIDBDatabaseIdentifier&, const String& databaseDirectory);
</del><ins>+ UniqueIDBDatabaseBackingStoreSQLite(const LegacyUniqueIDBDatabaseIdentifier&, const String& databaseDirectory);
</ins><span class="cx">
</span><span class="cx"> std::unique_ptr<WebCore::SQLiteDatabase> openSQLiteDatabaseAtPath(const String&);
</span><span class="cx"> std::unique_ptr<WebCore::IDBDatabaseMetadata> extractExistingMetadata();
</span><span class="lines">@@ -108,7 +108,7 @@
</span><span class="cx">
</span><span class="cx"> int idbKeyCollate(int aLength, const void* a, int bLength, const void* b);
</span><span class="cx">
</span><del>- UniqueIDBDatabaseIdentifier m_identifier;
</del><ins>+ LegacyUniqueIDBDatabaseIdentifier m_identifier;
</ins><span class="cx"> String m_absoluteDatabaseDirectory;
</span><span class="cx">
</span><span class="cx"> std::unique_ptr<WebCore::SQLiteDatabase> m_sqliteDB;
</span></span></pre></div>
<a id="trunkSourceWebKit2SharedWebCrossThreadCopiercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebKit2/Shared/WebCrossThreadCopier.cpp (196734 => 196735)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit2/Shared/WebCrossThreadCopier.cpp 2016-02-18 01:17:36 UTC (rev 196734)
+++ trunk/Source/WebKit2/Shared/WebCrossThreadCopier.cpp 2016-02-18 01:25:21 UTC (rev 196735)
</span><span class="lines">@@ -28,7 +28,7 @@
</span><span class="cx"> #if ENABLE(INDEXED_DATABASE)
</span><span class="cx">
</span><span class="cx"> #include "IDBIdentifier.h"
</span><del>-#include "UniqueIDBDatabaseIdentifier.h"
</del><ins>+#include "LegacyUniqueIDBDatabaseIdentifier.h"
</ins><span class="cx"> #include <WebCore/IDBKeyData.h>
</span><span class="cx"> #include <WebCore/SecurityOriginData.h>
</span><span class="cx">
</span><span class="lines">@@ -36,7 +36,7 @@
</span><span class="cx">
</span><span class="cx"> namespace WebCore {
</span><span class="cx">
</span><del>-UniqueIDBDatabaseIdentifier CrossThreadCopierBase<false, false, UniqueIDBDatabaseIdentifier>::copy(const UniqueIDBDatabaseIdentifier& identifier)
</del><ins>+LegacyUniqueIDBDatabaseIdentifier CrossThreadCopierBase<false, false, LegacyUniqueIDBDatabaseIdentifier>::copy(const LegacyUniqueIDBDatabaseIdentifier& identifier)
</ins><span class="cx"> {
</span><span class="cx"> return identifier.isolatedCopy();
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebKit2SharedWebCrossThreadCopierh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebKit2/Shared/WebCrossThreadCopier.h (196734 => 196735)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit2/Shared/WebCrossThreadCopier.h 2016-02-18 01:17:36 UTC (rev 196734)
+++ trunk/Source/WebKit2/Shared/WebCrossThreadCopier.h 2016-02-18 01:25:21 UTC (rev 196735)
</span><span class="lines">@@ -37,9 +37,9 @@
</span><span class="cx">
</span><span class="cx"> namespace WebKit {
</span><span class="cx"> class IDBIdentifier;
</span><del>-class UniqueIDBDatabaseIdentifier;
</del><ins>+class LegacyUniqueIDBDatabaseIdentifier;
</ins><span class="cx">
</span><del>-enum class UniqueIDBDatabaseShutdownType;
</del><ins>+enum class LegacyUniqueIDBDatabaseShutdownType;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> namespace WTF {
</span><span class="lines">@@ -48,8 +48,8 @@
</span><span class="cx">
</span><span class="cx"> namespace WebCore {
</span><span class="cx">
</span><del>-template<> struct CrossThreadCopierBase<false, false, WebKit::UniqueIDBDatabaseIdentifier> {
- static WebKit::UniqueIDBDatabaseIdentifier copy(const WebKit::UniqueIDBDatabaseIdentifier&);
</del><ins>+template<> struct CrossThreadCopierBase<false, false, WebKit::LegacyUniqueIDBDatabaseIdentifier> {
+ static WebKit::LegacyUniqueIDBDatabaseIdentifier copy(const WebKit::LegacyUniqueIDBDatabaseIdentifier&);
</ins><span class="cx"> };
</span><span class="cx">
</span><span class="cx"> template<> struct CrossThreadCopierBase<false, false, WebKit::IDBIdentifier> {
</span><span class="lines">@@ -57,8 +57,8 @@
</span><span class="cx"> };
</span><span class="cx">
</span><span class="cx">
</span><del>-template<> struct CrossThreadCopierBase<false, false, WebKit::UniqueIDBDatabaseShutdownType> {
- static WebKit::UniqueIDBDatabaseShutdownType copy(const WebKit::UniqueIDBDatabaseShutdownType& type)
</del><ins>+template<> struct CrossThreadCopierBase<false, false, WebKit::LegacyUniqueIDBDatabaseShutdownType> {
+ static WebKit::LegacyUniqueIDBDatabaseShutdownType copy(const WebKit::LegacyUniqueIDBDatabaseShutdownType& type)
</ins><span class="cx"> {
</span><span class="cx"> return type;
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebKit2WebKit2xcodeprojprojectpbxproj"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebKit2/WebKit2.xcodeproj/project.pbxproj (196734 => 196735)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit2/WebKit2.xcodeproj/project.pbxproj 2016-02-18 01:17:36 UTC (rev 196734)
+++ trunk/Source/WebKit2/WebKit2.xcodeproj/project.pbxproj 2016-02-18 01:25:21 UTC (rev 196735)
</span><span class="lines">@@ -848,6 +848,10 @@
</span><span class="cx"> 510523751C73D38F007993CB /* WebIDBConnectionToServerMessageReceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 510523721C73D37B007993CB /* WebIDBConnectionToServerMessageReceiver.cpp */; };
</span><span class="cx"> 510523791C73DA77007993CB /* WebIDBConnectionToClientMessageReceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 510523771C73DA70007993CB /* WebIDBConnectionToClientMessageReceiver.cpp */; };
</span><span class="cx"> 5105237A1C73DA77007993CB /* WebIDBConnectionToClientMessages.h in Headers */ = {isa = PBXBuildFile; fileRef = 510523781C73DA70007993CB /* WebIDBConnectionToClientMessages.h */; };
</span><ins>+ 5105237F1C7541FF007993CB /* LegacyUniqueIDBDatabase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5105237B1C7541F3007993CB /* LegacyUniqueIDBDatabase.cpp */; };
+ 510523801C7541FF007993CB /* LegacyUniqueIDBDatabase.h in Headers */ = {isa = PBXBuildFile; fileRef = 5105237C1C7541F3007993CB /* LegacyUniqueIDBDatabase.h */; };
+ 510523811C7541FF007993CB /* LegacyUniqueIDBDatabaseIdentifier.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5105237D1C7541F3007993CB /* LegacyUniqueIDBDatabaseIdentifier.cpp */; };
+ 510523821C7541FF007993CB /* LegacyUniqueIDBDatabaseIdentifier.h in Headers */ = {isa = PBXBuildFile; fileRef = 5105237E1C7541F3007993CB /* LegacyUniqueIDBDatabaseIdentifier.h */; };
</ins><span class="cx"> 51064D35189781C4004B2FEB /* SQLiteIDBCursor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 51064D33189781C4004B2FEB /* SQLiteIDBCursor.cpp */; };
</span><span class="cx"> 51064D36189781C4004B2FEB /* SQLiteIDBCursor.h in Headers */ = {isa = PBXBuildFile; fileRef = 51064D34189781C4004B2FEB /* SQLiteIDBCursor.h */; };
</span><span class="cx"> 5106D7C218BDBE73000AB166 /* ContextMenuContextData.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5106D7BF18BDBE73000AB166 /* ContextMenuContextData.cpp */; };
</span><span class="lines">@@ -918,10 +922,6 @@
</span><span class="cx"> 515E7728183DD6F60007203F /* AsyncRequest.h in Headers */ = {isa = PBXBuildFile; fileRef = 515E7726183DD6F60007203F /* AsyncRequest.h */; };
</span><span class="cx"> 515E772B184008B90007203F /* DatabaseProcessCreationParameters.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 515E7729184008B90007203F /* DatabaseProcessCreationParameters.cpp */; };
</span><span class="cx"> 515E772C184008B90007203F /* DatabaseProcessCreationParameters.h in Headers */ = {isa = PBXBuildFile; fileRef = 515E772A184008B90007203F /* DatabaseProcessCreationParameters.h */; };
</span><del>- 515E772F184015800007203F /* UniqueIDBDatabase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 515E772D184015800007203F /* UniqueIDBDatabase.cpp */; };
- 515E7730184015800007203F /* UniqueIDBDatabase.h in Headers */ = {isa = PBXBuildFile; fileRef = 515E772E184015800007203F /* UniqueIDBDatabase.h */; };
- 515E773318402D510007203F /* UniqueIDBDatabaseIdentifier.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 515E773118402D510007203F /* UniqueIDBDatabaseIdentifier.cpp */; };
- 515E773418402D510007203F /* UniqueIDBDatabaseIdentifier.h in Headers */ = {isa = PBXBuildFile; fileRef = 515E773218402D510007203F /* UniqueIDBDatabaseIdentifier.h */; };
</del><span class="cx"> 5160BFE113381DF900918999 /* LoggingFoundation.mm in Sources */ = {isa = PBXBuildFile; fileRef = 5160BFE013381DF900918999 /* LoggingFoundation.mm */; };
</span><span class="cx"> 516311871858446600534647 /* WebCrossThreadCopier.h in Headers */ = {isa = PBXBuildFile; fileRef = 516311861858446600534647 /* WebCrossThreadCopier.h */; };
</span><span class="cx"> 516319921628980A00E22F00 /* NetworkProcessProxyMac.mm in Sources */ = {isa = PBXBuildFile; fileRef = 516319911628980A00E22F00 /* NetworkProcessProxyMac.mm */; };
</span><span class="lines">@@ -2837,6 +2837,10 @@
</span><span class="cx"> 510523761C73D9F6007993CB /* WebIDBConnectionToClient.messages.in */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = WebIDBConnectionToClient.messages.in; sourceTree = "<group>"; };
</span><span class="cx"> 510523771C73DA70007993CB /* WebIDBConnectionToClientMessageReceiver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WebIDBConnectionToClientMessageReceiver.cpp; sourceTree = "<group>"; };
</span><span class="cx"> 510523781C73DA70007993CB /* WebIDBConnectionToClientMessages.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebIDBConnectionToClientMessages.h; sourceTree = "<group>"; };
</span><ins>+ 5105237B1C7541F3007993CB /* LegacyUniqueIDBDatabase.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LegacyUniqueIDBDatabase.cpp; sourceTree = "<group>"; };
+ 5105237C1C7541F3007993CB /* LegacyUniqueIDBDatabase.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LegacyUniqueIDBDatabase.h; sourceTree = "<group>"; };
+ 5105237D1C7541F3007993CB /* LegacyUniqueIDBDatabaseIdentifier.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LegacyUniqueIDBDatabaseIdentifier.cpp; sourceTree = "<group>"; };
+ 5105237E1C7541F3007993CB /* LegacyUniqueIDBDatabaseIdentifier.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LegacyUniqueIDBDatabaseIdentifier.h; sourceTree = "<group>"; };
</ins><span class="cx"> 5105B0D4162F7A7A00E27709 /* NetworkProcessConnection.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = NetworkProcessConnection.cpp; path = Network/NetworkProcessConnection.cpp; sourceTree = "<group>"; };
</span><span class="cx"> 5105B0D5162F7A7A00E27709 /* NetworkProcessConnection.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = NetworkProcessConnection.h; path = Network/NetworkProcessConnection.h; sourceTree = "<group>"; };
</span><span class="cx"> 5105B0F31630872E00E27709 /* NetworkProcessProxy.messages.in */ = {isa = PBXFileReference; lastKnownFileType = text; path = NetworkProcessProxy.messages.in; sourceTree = "<group>"; };
</span><span class="lines">@@ -2915,10 +2919,6 @@
</span><span class="cx"> 515E7726183DD6F60007203F /* AsyncRequest.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AsyncRequest.h; sourceTree = "<group>"; };
</span><span class="cx"> 515E7729184008B90007203F /* DatabaseProcessCreationParameters.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DatabaseProcessCreationParameters.cpp; sourceTree = "<group>"; };
</span><span class="cx"> 515E772A184008B90007203F /* DatabaseProcessCreationParameters.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DatabaseProcessCreationParameters.h; sourceTree = "<group>"; };
</span><del>- 515E772D184015800007203F /* UniqueIDBDatabase.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = UniqueIDBDatabase.cpp; sourceTree = "<group>"; };
- 515E772E184015800007203F /* UniqueIDBDatabase.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = UniqueIDBDatabase.h; sourceTree = "<group>"; };
- 515E773118402D510007203F /* UniqueIDBDatabaseIdentifier.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = UniqueIDBDatabaseIdentifier.cpp; sourceTree = "<group>"; };
- 515E773218402D510007203F /* UniqueIDBDatabaseIdentifier.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = UniqueIDBDatabaseIdentifier.h; sourceTree = "<group>"; };
</del><span class="cx"> 5160BFE013381DF900918999 /* LoggingFoundation.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = LoggingFoundation.mm; sourceTree = "<group>"; };
</span><span class="cx"> 516311861858446600534647 /* WebCrossThreadCopier.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebCrossThreadCopier.h; sourceTree = "<group>"; };
</span><span class="cx"> 516319911628980A00E22F00 /* NetworkProcessProxyMac.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = NetworkProcessProxyMac.mm; path = mac/NetworkProcessProxyMac.mm; sourceTree = "<group>"; };
</span><span class="lines">@@ -5418,11 +5418,11 @@
</span><span class="cx"> 517509591897249700408FAC /* IDBIdentifier.h */,
</span><span class="cx"> 518353D81885BF8C00D9FE44 /* IDBSerialization.cpp */,
</span><span class="cx"> 518353D91885BF8C00D9FE44 /* IDBSerialization.h */,
</span><del>- 515E772D184015800007203F /* UniqueIDBDatabase.cpp */,
- 515E772E184015800007203F /* UniqueIDBDatabase.h */,
</del><ins>+ 5105237B1C7541F3007993CB /* LegacyUniqueIDBDatabase.cpp */,
+ 5105237C1C7541F3007993CB /* LegacyUniqueIDBDatabase.h */,
+ 5105237D1C7541F3007993CB /* LegacyUniqueIDBDatabaseIdentifier.cpp */,
+ 5105237E1C7541F3007993CB /* LegacyUniqueIDBDatabaseIdentifier.h */,
</ins><span class="cx"> 51654EFF184EF34A007DC837 /* UniqueIDBDatabaseBackingStore.h */,
</span><del>- 515E773118402D510007203F /* UniqueIDBDatabaseIdentifier.cpp */,
- 515E773218402D510007203F /* UniqueIDBDatabaseIdentifier.h */,
</del><span class="cx"> 5105236D1C7393E9007993CB /* WebIDBConnectionToClient.cpp */,
</span><span class="cx"> 5105236E1C7393E9007993CB /* WebIDBConnectionToClient.h */,
</span><span class="cx"> 510523761C73D9F6007993CB /* WebIDBConnectionToClient.messages.in */,
</span><span class="lines">@@ -7351,9 +7351,11 @@
</span><span class="cx"> 512935E41288D97800A4B695 /* InjectedBundlePageContextMenuClient.h in Headers */,
</span><span class="cx"> E1EE53E311F8CFC000CCBEE4 /* InjectedBundlePageEditorClient.h in Headers */,
</span><span class="cx"> BC14E10A120B905E00826C0C /* InjectedBundlePageFormClient.h in Headers */,
</span><ins>+ 510523821C7541FF007993CB /* LegacyUniqueIDBDatabaseIdentifier.h in Headers */,
</ins><span class="cx"> 990D28C11C65626500986977 /* WebAutomationSession.h in Headers */,
</span><span class="cx"> CD5C66A1134B9D38004FE2A8 /* InjectedBundlePageFullScreenClient.h in Headers */,
</span><span class="cx"> BCA8C6A911E3BA5F00812FB7 /* InjectedBundlePageLoaderClient.h in Headers */,
</span><ins>+ 510523801C7541FF007993CB /* LegacyUniqueIDBDatabase.h in Headers */,
</ins><span class="cx"> BC8147A912F64CDA007B2C32 /* InjectedBundlePagePolicyClient.h in Headers */,
</span><span class="cx"> BCA8C6B011E3C08700812FB7 /* InjectedBundlePageUIClient.h in Headers */,
</span><span class="cx"> BC33E0D112408E8600360F3F /* InjectedBundleRangeHandle.h in Headers */,
</span><span class="lines">@@ -7547,10 +7549,8 @@
</span><span class="cx"> 1AF05D8714688348008B1E81 /* TiledCoreAnimationDrawingAreaProxy.h in Headers */,
</span><span class="cx"> 1AFE436618B6C081009C7A48 /* UIDelegate.h in Headers */,
</span><span class="cx"> CEE4AE2B1A5DCF430002F49B /* UIKitSPI.h in Headers */,
</span><del>- 515E7730184015800007203F /* UniqueIDBDatabase.h in Headers */,
</del><span class="cx"> 51654F00184EF34A007DC837 /* UniqueIDBDatabaseBackingStore.h in Headers */,
</span><span class="cx"> 51654EFE184EF33F007DC837 /* UniqueIDBDatabaseBackingStoreSQLite.h in Headers */,
</span><del>- 515E773418402D510007203F /* UniqueIDBDatabaseIdentifier.h in Headers */,
</del><span class="cx"> 1A64245E12DE29A100CAAE2C /* UpdateInfo.h in Headers */,
</span><span class="cx"> 1AC1336818565B5700F3EC05 /* UserData.h in Headers */,
</span><span class="cx"> 4A3CC18B19B0640F00D14AEF /* UserMediaPermissionRequestManagerProxy.h in Headers */,
</span><span class="lines">@@ -8823,6 +8823,7 @@
</span><span class="cx"> C0E3AA7B1209E83500A49D01 /* Module.cpp in Sources */,
</span><span class="cx"> C0E3AA7A1209E83000A49D01 /* ModuleCF.cpp in Sources */,
</span><span class="cx"> 2D50365E1BCC793F00E20BB3 /* NativeWebGestureEventMac.mm in Sources */,
</span><ins>+ 510523811C7541FF007993CB /* LegacyUniqueIDBDatabaseIdentifier.cpp in Sources */,
</ins><span class="cx"> 2DA9449E1884E4F000ED86DB /* NativeWebKeyboardEventIOS.mm in Sources */,
</span><span class="cx"> C02BFF1E1251502E009CCBEA /* NativeWebKeyboardEventMac.mm in Sources */,
</span><span class="cx"> 31EA25D2134F78C0005B1452 /* NativeWebMouseEventMac.mm in Sources */,
</span><span class="lines">@@ -8832,6 +8833,7 @@
</span><span class="cx"> 1ABC3DF51899E437004F0626 /* NavigationState.mm in Sources */,
</span><span class="cx"> 1A6FBA2B11E6862700DB1371 /* NetscapeBrowserFuncs.cpp in Sources */,
</span><span class="cx"> 1A6FBD2911E69BC200DB1371 /* NetscapePlugin.cpp in Sources */,
</span><ins>+ 5105237F1C7541FF007993CB /* LegacyUniqueIDBDatabase.cpp in Sources */,
</ins><span class="cx"> 1AE5B7FB11E7AED200BA6767 /* NetscapePluginMac.mm in Sources */,
</span><span class="cx"> 1A4A9C5512B816CF008FE984 /* NetscapePluginModule.cpp in Sources */,
</span><span class="cx"> 1A4A9C9A12B821CD008FE984 /* NetscapePluginModuleMac.mm in Sources */,
</span><span class="lines">@@ -9015,9 +9017,7 @@
</span><span class="cx"> 1AAF263814687C39004A1E8A /* TiledCoreAnimationDrawingArea.mm in Sources */,
</span><span class="cx"> 1AF05D8614688348008B1E81 /* TiledCoreAnimationDrawingAreaProxy.mm in Sources */,
</span><span class="cx"> 1AFE436518B6C081009C7A48 /* UIDelegate.mm in Sources */,
</span><del>- 515E772F184015800007203F /* UniqueIDBDatabase.cpp in Sources */,
</del><span class="cx"> 51654EFD184EF33F007DC837 /* UniqueIDBDatabaseBackingStoreSQLite.cpp in Sources */,
</span><del>- 515E773318402D510007203F /* UniqueIDBDatabaseIdentifier.cpp in Sources */,
</del><span class="cx"> 1A64245F12DE29A100CAAE2C /* UpdateInfo.cpp in Sources */,
</span><span class="cx"> 1AC1336718565B5700F3EC05 /* UserData.cpp in Sources */,
</span><span class="cx"> 15739BBC1B42040300D258C1 /* UserMediaPermissionRequestManager.cpp in Sources */,
</span></span></pre>
</div>
</div>
</body>
</html>