⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 248751 in webkit


Ignore:
Timestamp:
Aug 15, 2019, 5:12:42 PM (7 years ago)
Author:
sihui_liu@apple.com
Message:

Use one VM per thread for IDB serialization work in network process
​https://bugs.webkit.org/show_bug.cgi?id=200526

Reviewed by Geoffrey Garen.

We had one static VM in UniqueIDBDatabase for serialization/deserialization in MemoryObjectStore. This VM was
never destroyed and could be used on different background threads.

We also had one VM per SQLiteIDBBackingStore for serialization/deserialization in SQLiteIDBBackingStore. If
there were multiple IndexedDB databases of the same session opened, we would have multiple VMs created
on the same thread. Each VM has its memory allocator and garbage collector, which takes up memory.

To be more memory efficient and safe, we can use one VM per thread in the network process, and create/destroy
the VMs on demand.

  • Modules/indexeddb/server/IDBSerializationContext.cpp: Added.

(WebCore::IDBServer::IDBSerializationContext::getOrCreateIDBSerializationContext):
(WebCore::IDBServer::IDBSerializationContext::~IDBSerializationContext):
(WebCore::IDBServer::IDBSerializationContext::initializeVM):
(WebCore::IDBServer::IDBSerializationContext::vm):
(WebCore::IDBServer::IDBSerializationContext::execState):
(WebCore::IDBServer::IDBSerializationContext::IDBSerializationContext):

  • Modules/indexeddb/server/IDBSerializationContext.h: Added.
  • Modules/indexeddb/server/IDBServer.cpp:

(WebCore::IDBServer::IDBServer::createBackingStore):

  • Modules/indexeddb/server/MemoryIDBBackingStore.cpp:

(WebCore::IDBServer::MemoryIDBBackingStore::create):
(WebCore::IDBServer::MemoryIDBBackingStore::MemoryIDBBackingStore):
(WebCore::IDBServer::MemoryIDBBackingStore::createObjectStore):

  • Modules/indexeddb/server/MemoryIDBBackingStore.h:
  • Modules/indexeddb/server/MemoryObjectStore.cpp:

(WebCore::IDBServer::MemoryObjectStore::create):
(WebCore::IDBServer::MemoryObjectStore::MemoryObjectStore):
(WebCore::IDBServer::MemoryObjectStore::updateIndexesForPutRecord):
(WebCore::IDBServer::MemoryObjectStore::populateIndexWithExistingRecords):

  • Modules/indexeddb/server/MemoryObjectStore.h:
  • Modules/indexeddb/server/SQLiteIDBBackingStore.cpp:

(WebCore::IDBServer::SQLiteIDBBackingStore::SQLiteIDBBackingStore):
(WebCore::IDBServer::SQLiteIDBBackingStore::~SQLiteIDBBackingStore):
(WebCore::IDBServer::SQLiteIDBBackingStore::updateOneIndexForAddRecord):
(WebCore::IDBServer::SQLiteIDBBackingStore::updateAllIndexesForAddRecord):
(WebCore::IDBServer::SQLiteIDBBackingStore::initializeVM): Deleted.
(WebCore::IDBServer::SQLiteIDBBackingStore::vm): Deleted.
(WebCore::IDBServer::SQLiteIDBBackingStore::globalObject): Deleted.

  • Modules/indexeddb/server/SQLiteIDBBackingStore.h:
  • Modules/indexeddb/server/UniqueIDBDatabase.cpp:

(WebCore::IDBServer::UniqueIDBDatabase::databaseThreadVM): Deleted.
(WebCore::IDBServer::UniqueIDBDatabase::databaseThreadExecState): Deleted.

  • Modules/indexeddb/server/UniqueIDBDatabase.h:
  • Sources.txt:
Location:
trunk/Source/WebCore
Files:
2 added
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r248750 r248751  
     12019-08-15  Sihui Liu  <sihui_liu@apple.com>
     2
     3        Use one VM per thread for IDB serialization work in network process
     4        https://bugs.webkit.org/show_bug.cgi?id=200526
     5
     6        Reviewed by Geoffrey Garen.
     7
     8        We had one static VM in UniqueIDBDatabase for serialization/deserialization in MemoryObjectStore. This VM was
     9        never destroyed and could be used on different background threads.
     10 
     11        We also had one VM per SQLiteIDBBackingStore for serialization/deserialization in SQLiteIDBBackingStore. If
     12        there were multiple IndexedDB databases of the same session opened, we would have multiple VMs created
     13        on the same thread. Each VM has its memory allocator and garbage collector, which takes up memory.
     14 
     15        To be more memory efficient and safe, we can use one VM per thread in the network process, and create/destroy
     16        the VMs on demand.
     17
     18        * Modules/indexeddb/server/IDBSerializationContext.cpp: Added.
     19        (WebCore::IDBServer::IDBSerializationContext::getOrCreateIDBSerializationContext):
     20        (WebCore::IDBServer::IDBSerializationContext::~IDBSerializationContext):
     21        (WebCore::IDBServer::IDBSerializationContext::initializeVM):
     22        (WebCore::IDBServer::IDBSerializationContext::vm):
     23        (WebCore::IDBServer::IDBSerializationContext::execState):
     24        (WebCore::IDBServer::IDBSerializationContext::IDBSerializationContext):
     25        * Modules/indexeddb/server/IDBSerializationContext.h: Added.
     26        * Modules/indexeddb/server/IDBServer.cpp:
     27        (WebCore::IDBServer::IDBServer::createBackingStore):
     28        * Modules/indexeddb/server/MemoryIDBBackingStore.cpp:
     29        (WebCore::IDBServer::MemoryIDBBackingStore::create):
     30        (WebCore::IDBServer::MemoryIDBBackingStore::MemoryIDBBackingStore):
     31        (WebCore::IDBServer::MemoryIDBBackingStore::createObjectStore):
     32        * Modules/indexeddb/server/MemoryIDBBackingStore.h:
     33        * Modules/indexeddb/server/MemoryObjectStore.cpp:
     34        (WebCore::IDBServer::MemoryObjectStore::create):
     35        (WebCore::IDBServer::MemoryObjectStore::MemoryObjectStore):
     36        (WebCore::IDBServer::MemoryObjectStore::updateIndexesForPutRecord):
     37        (WebCore::IDBServer::MemoryObjectStore::populateIndexWithExistingRecords):
     38        * Modules/indexeddb/server/MemoryObjectStore.h:
     39        * Modules/indexeddb/server/SQLiteIDBBackingStore.cpp:
     40        (WebCore::IDBServer::SQLiteIDBBackingStore::SQLiteIDBBackingStore):
     41        (WebCore::IDBServer::SQLiteIDBBackingStore::~SQLiteIDBBackingStore):
     42        (WebCore::IDBServer::SQLiteIDBBackingStore::updateOneIndexForAddRecord):
     43        (WebCore::IDBServer::SQLiteIDBBackingStore::updateAllIndexesForAddRecord):
     44        (WebCore::IDBServer::SQLiteIDBBackingStore::initializeVM): Deleted.
     45        (WebCore::IDBServer::SQLiteIDBBackingStore::vm): Deleted.
     46        (WebCore::IDBServer::SQLiteIDBBackingStore::globalObject): Deleted.
     47        * Modules/indexeddb/server/SQLiteIDBBackingStore.h:
     48        * Modules/indexeddb/server/UniqueIDBDatabase.cpp:
     49        (WebCore::IDBServer::UniqueIDBDatabase::databaseThreadVM): Deleted.
     50        (WebCore::IDBServer::UniqueIDBDatabase::databaseThreadExecState): Deleted.
     51        * Modules/indexeddb/server/UniqueIDBDatabase.h:
     52        * Sources.txt:
     53
    1542019-08-15  Zalan Bujtas  <zalan@apple.com>
    255

  • trunk/Source/WebCore/Modules/indexeddb/server/IDBServer.cpp

    r248699 r248751  
    134134
    135135    if (m_databaseDirectoryPath.isEmpty())
    136         return MemoryIDBBackingStore::create(identifier);
     136        return MemoryIDBBackingStore::create(m_sessionID, identifier);
    137137
    138138    return std::make_unique<SQLiteIDBBackingStore>(m_sessionID, identifier, m_databaseDirectoryPath, m_backingStoreTemporaryFileHandler, m_perOriginQuota);

  • trunk/Source/WebCore/Modules/indexeddb/server/MemoryIDBBackingStore.cpp

    r244436 r248751  
    4747static uint64_t maxGeneratedKeyValue = 0x20000000000000;
    4848
    49 std::unique_ptr<MemoryIDBBackingStore> MemoryIDBBackingStore::create(const IDBDatabaseIdentifier& identifier)
    50 {
    51     return std::make_unique<MemoryIDBBackingStore>(identifier);
    52 }
    53 
    54 MemoryIDBBackingStore::MemoryIDBBackingStore(const IDBDatabaseIdentifier& identifier)
     49std::unique_ptr<MemoryIDBBackingStore> MemoryIDBBackingStore::create(PAL::SessionID sessionID, const IDBDatabaseIdentifier& identifier)
     50{
     51    return std::make_unique<MemoryIDBBackingStore>(sessionID, identifier);
     52}
     53
     54MemoryIDBBackingStore::MemoryIDBBackingStore(PAL::SessionID sessionID, const IDBDatabaseIdentifier& identifier)
    5555    : m_identifier(identifier)
     56    , m_sessionID(sessionID)
    5657{
    5758}
    … …  
    136137
    137138    ASSERT(!m_objectStoresByIdentifier.contains(info.identifier()));
    138     auto objectStore = MemoryObjectStore::create(info);
     139    auto objectStore = MemoryObjectStore::create(m_sessionID, info);
    139140
    140141    m_databaseInfo->addExistingObjectStore(info);

  • trunk/Source/WebCore/Modules/indexeddb/server/MemoryIDBBackingStore.h

    r248699 r248751  
    4242    WTF_MAKE_FAST_ALLOCATED;
    4343public:
    44     static std::unique_ptr<MemoryIDBBackingStore> create(const IDBDatabaseIdentifier&);
     44    static std::unique_ptr<MemoryIDBBackingStore> create(PAL::SessionID, const IDBDatabaseIdentifier&);
    4545   
    46     MemoryIDBBackingStore(const IDBDatabaseIdentifier&);
     46    MemoryIDBBackingStore(PAL::SessionID, const IDBDatabaseIdentifier&);
    4747    ~MemoryIDBBackingStore() final;
    4848
    … …  
    9292
    9393    IDBDatabaseIdentifier m_identifier;
     94    PAL::SessionID m_sessionID;
    9495    std::unique_ptr<IDBDatabaseInfo> m_databaseInfo;
    9596

  • trunk/Source/WebCore/Modules/indexeddb/server/MemoryObjectStore.cpp

    r244436 r248751  
    3333#include "IDBGetAllResult.h"
    3434#include "IDBKeyRangeData.h"
     35#include "IDBSerializationContext.h"
    3536#include "IDBValue.h"
    3637#include "IndexKey.h"
    … …  
    4647namespace IDBServer {
    4748
    48 Ref<MemoryObjectStore> MemoryObjectStore::create(const IDBObjectStoreInfo& info)
    49 {
    50     return adoptRef(*new MemoryObjectStore(info));
    51 }
    52 
    53 MemoryObjectStore::MemoryObjectStore(const IDBObjectStoreInfo& info)
     49Ref<MemoryObjectStore> MemoryObjectStore::create(PAL::SessionID sessionID, const IDBObjectStoreInfo& info)
     50{
     51    return adoptRef(*new MemoryObjectStore(sessionID, info));
     52}
     53
     54MemoryObjectStore::MemoryObjectStore(PAL::SessionID sessionID, const IDBObjectStoreInfo& info)
    5455    : m_info(info)
     56    , m_serializationContext(IDBSerializationContext::getOrCreateIDBSerializationContext(sessionID))
    5557{
    5658}
    … …  
    300302IDBError MemoryObjectStore::updateIndexesForPutRecord(const IDBKeyData& key, const ThreadSafeDataBuffer& value)
    301303{
    302     JSLockHolder locker(UniqueIDBDatabase::databaseThreadVM());
    303 
    304     auto jsValue = deserializeIDBValueToJSValue(UniqueIDBDatabase::databaseThreadExecState(), value);
     304    JSLockHolder locker(m_serializationContext->vm());
     305
     306    auto jsValue = deserializeIDBValueToJSValue(m_serializationContext->execState(), value);
    305307    if (jsValue.isUndefinedOrNull())
    306308        return IDBError { };
    … …  
    311313    for (auto& index : m_indexesByName.values()) {
    312314        IndexKey indexKey;
    313         generateIndexKeyForValue(UniqueIDBDatabase::databaseThreadExecState(), index->info(), jsValue, indexKey, m_info.keyPath(), key);
     315        generateIndexKeyForValue(m_serializationContext->execState(), index->info(), jsValue, indexKey, m_info.keyPath(), key);
    314316
    315317        if (indexKey.isNull())
    … …  
    337339        return IDBError { };
    338340
    339     JSLockHolder locker(UniqueIDBDatabase::databaseThreadVM());
     341    JSLockHolder locker(m_serializationContext->vm());
    340342
    341343    for (const auto& iterator : *m_keyValueStore) {
    342         auto jsValue = deserializeIDBValueToJSValue(UniqueIDBDatabase::databaseThreadExecState(), iterator.value);
     344        auto jsValue = deserializeIDBValueToJSValue(m_serializationContext->execState(), iterator.value);
    343345        if (jsValue.isUndefinedOrNull())
    344346            return IDBError { };
    345347
    346348        IndexKey indexKey;
    347         generateIndexKeyForValue(UniqueIDBDatabase::databaseThreadExecState(), index.info(), jsValue, indexKey, m_info.keyPath(), iterator.key);
     349        generateIndexKeyForValue(m_serializationContext->execState(), index.info(), jsValue, indexKey, m_info.keyPath(), iterator.key);
    348350
    349351        if (indexKey.isNull())

  • trunk/Source/WebCore/Modules/indexeddb/server/MemoryObjectStore.h

    r239427 r248751  
    3636#include <wtf/RefCounted.h>
    3737
     38namespace PAL {
     39class SessionID;
     40}
     41
    3842namespace WebCore {
    3943
    … …  
    5357namespace IDBServer {
    5458
     59class IDBSerializationContext;
    5560class MemoryBackingStoreTransaction;
    5661
    … …  
    5964class MemoryObjectStore : public RefCounted<MemoryObjectStore> {
    6065public:
    61     static Ref<MemoryObjectStore> create(const IDBObjectStoreInfo&);
     66    static Ref<MemoryObjectStore> create(PAL::SessionID, const IDBObjectStoreInfo&);
    6267
    6368    ~MemoryObjectStore();
    … …  
    105110
    106111private:
    107     MemoryObjectStore(const IDBObjectStoreInfo&);
     112    MemoryObjectStore(PAL::SessionID, const IDBObjectStoreInfo&);
    108113
    109114    IDBKeyDataSet::iterator lowestIteratorInRange(const IDBKeyRangeData&, bool reverse) const;
    … …  
    129134    HashMap<String, RefPtr<MemoryIndex>> m_indexesByName;
    130135    HashMap<IDBResourceIdentifier, std::unique_ptr<MemoryObjectStoreCursor>> m_cursors;
     136
     137    Ref<IDBSerializationContext> m_serializationContext;
    131138};
    132139

  • trunk/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.cpp

    r248699 r248751  
    3939#include "IDBObjectStoreInfo.h"
    4040#include "IDBSerialization.h"
     41#include "IDBSerializationContext.h"
    4142#include "IDBTransactionInfo.h"
    4243#include "IDBValue.h"
    … …  
    235236    , m_temporaryFileHandler(fileHandler)
    236237    , m_quota(quota)
     238    , m_serializationContext(IDBSerializationContext::getOrCreateIDBSerializationContext(sessionID))
    237239{
    238240    m_databaseDirectory = fullDatabaseDirectoryWithUpgrade();
    … …  
    243245    if (m_sqliteDB)
    244246        closeSQLiteDB();
    245 
    246     if (m_vm) {
    247         JSLockHolder locker(m_vm.get());
    248         m_globalObject.clear();
    249         m_vm = nullptr;
    250     }
    251 }
    252 
    253 
    254 void SQLiteIDBBackingStore::initializeVM()
    255 {
    256     if (!m_vm) {
    257         ASSERT(!m_globalObject);
    258         m_vm = VM::create();
    259 
    260         JSLockHolder locker(m_vm.get());
    261         m_globalObject.set(*m_vm, JSGlobalObject::create(*m_vm, JSGlobalObject::createStructure(*m_vm, jsNull())));
    262     }
    263 }
    264 
    265 VM& SQLiteIDBBackingStore::vm()
    266 {
    267     initializeVM();
    268     return *m_vm;
    269 }
    270 
    271 JSGlobalObject& SQLiteIDBBackingStore::globalObject()
    272 {
    273     initializeVM();
    274     return **m_globalObject;
    275247}
    276248
    … …  
    17331705IDBError SQLiteIDBBackingStore::updateOneIndexForAddRecord(const IDBIndexInfo& info, const IDBKeyData& key, const ThreadSafeDataBuffer& value, int64_t recordID)
    17341706{
    1735     JSLockHolder locker(vm());
    1736 
    1737     auto jsValue = deserializeIDBValueToJSValue(*globalObject().globalExec(), value);
     1707    JSLockHolder locker(m_serializationContext->vm());
     1708
     1709    auto jsValue = deserializeIDBValueToJSValue(m_serializationContext->execState(), value);
    17381710    if (jsValue.isUndefinedOrNull())
    17391711        return IDBError { };
    … …  
    17421714    auto* objectStoreInfo = infoForObjectStore(info.objectStoreIdentifier());
    17431715    ASSERT(objectStoreInfo);
    1744     generateIndexKeyForValue(*m_globalObject->globalExec(), info, jsValue, indexKey, objectStoreInfo->keyPath(), key);
     1716    generateIndexKeyForValue(m_serializationContext->execState(), info, jsValue, indexKey, objectStoreInfo->keyPath(), key);
    17451717
    17461718    if (indexKey.isNull())
    … …  
    17521724IDBError SQLiteIDBBackingStore::updateAllIndexesForAddRecord(const IDBObjectStoreInfo& info, const IDBKeyData& key, const ThreadSafeDataBuffer& value, int64_t recordID)
    17531725{
    1754     JSLockHolder locker(vm());
    1755 
    1756     auto jsValue = deserializeIDBValueToJSValue(*globalObject().globalExec(), value);
     1726    JSLockHolder locker(m_serializationContext->vm());
     1727
     1728    auto jsValue = deserializeIDBValueToJSValue(m_serializationContext->execState(), value);
    17571729    if (jsValue.isUndefinedOrNull())
    17581730        return IDBError { };
    … …  
    17621734    for (auto& index : info.indexMap().values()) {
    17631735        IndexKey indexKey;
    1764         generateIndexKeyForValue(*m_globalObject->globalExec(), index, jsValue, indexKey, info.keyPath(), key);
     1736        generateIndexKeyForValue(m_serializationContext->execState(), index, jsValue, indexKey, info.keyPath(), key);
    17651737
    17661738        if (indexKey.isNull())

  • trunk/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.h

    r248699 r248751  
    4444namespace IDBServer {
    4545
     46class IDBSerializationContext;
    4647class SQLiteIDBCursor;
    4748
    … …  
    191192    std::unique_ptr<SQLiteStatement> m_cachedStatements[static_cast<int>(SQL::Count)];
    192193
    193     JSC::VM& vm();
    194     JSC::JSGlobalObject& globalObject();
    195     void initializeVM();
    196 
    197194    PAL::SessionID m_sessionID;
    198195    IDBDatabaseIdentifier m_identifier;
    … …  
    208205    String m_databaseDirectory;
    209206
    210     RefPtr<JSC::VM> m_vm;
    211     JSC::Strong<JSC::JSGlobalObject> m_globalObject;
    212 
    213207    IDBBackingStoreTemporaryFileHandler& m_temporaryFileHandler;
    214208   
    215209    uint64_t m_quota;
     210
     211    Ref<IDBSerializationContext> m_serializationContext;
    216212};
    217213

  • trunk/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp

    r248699 r248751  
    11981198}
    11991199
    1200 VM& UniqueIDBDatabase::databaseThreadVM()
    1201 {
    1202     ASSERT(!isMainThread());
    1203     static VM* vm = &VM::create().leakRef();
    1204     return *vm;
    1205 }
    1206 
    1207 ExecState& UniqueIDBDatabase::databaseThreadExecState()
    1208 {
    1209     ASSERT(!isMainThread());
    1210 
    1211     static NeverDestroyed<Strong<JSGlobalObject>> globalObject(databaseThreadVM(), JSGlobalObject::create(databaseThreadVM(), JSGlobalObject::createStructure(databaseThreadVM(), jsNull())));
    1212 
    1213     RELEASE_ASSERT(globalObject.get()->globalExec());
    1214     return *globalObject.get()->globalExec();
    1215 }
    1216 
    12171200void UniqueIDBDatabase::performPutOrAdd(uint64_t callbackIdentifier, const IDBResourceIdentifier& transactionIdentifier, uint64_t objectStoreIdentifier, const IDBKeyData& keyData, const IDBValue& originalRecordValue, IndexedDB::ObjectStoreOverwriteMode overwriteMode)
    12181201{

  • trunk/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.h

    r248699 r248751  
    4343#include <wtf/ListHashSet.h>
    4444
    45 namespace JSC {
    46 class ExecState;
    47 class VM;
    48 }
    49 
    5045namespace WebCore {
    5146
    … …  
    119114    void handleDelete(IDBConnectionToClient&, const IDBRequestData&);
    120115    void immediateCloseForUserDelete();
    121 
    122     static JSC::VM& databaseThreadVM();
    123     static JSC::ExecState& databaseThreadExecState();
    124116
    125117    bool hardClosedForUserDelete() const { return m_hardClosedForUserDelete; }

  • trunk/Source/WebCore/Sources.txt

    r248657 r248751  
    103103Modules/indexeddb/server/IDBConnectionToClient.cpp
    104104Modules/indexeddb/server/IDBSerialization.cpp
     105Modules/indexeddb/server/IDBSerializationContext.cpp
    105106Modules/indexeddb/server/IDBServer.cpp
    106107Modules/indexeddb/server/IndexValueEntry.cpp

  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r248713 r248751  
    25472547                931CBD11161A44E900E4C874 /* ScrollingStateTree.h in Headers */ = {isa = PBXBuildFile; fileRef = 931CBD0B161A44E900E4C874 /* ScrollingStateTree.h */; settings = {ATTRIBUTES = (Private, ); }; };
    25482548                931D72F615FE695300C4C07E /* LayoutMilestone.h in Headers */ = {isa = PBXBuildFile; fileRef = 931D72F515FE695300C4C07E /* LayoutMilestone.h */; settings = {ATTRIBUTES = (Private, ); }; };
     2549                9323B07023061F9700901C8B /* IDBSerializationContext.h in Headers */ = {isa = PBXBuildFile; fileRef = 9323B06F23061E9C00901C8B /* IDBSerializationContext.h */; };
    25492550                932CC0B71DFFD158004C0F9F /* MediaTrackConstraints.h in Headers */ = {isa = PBXBuildFile; fileRef = 932CC0B61DFFD158004C0F9F /* MediaTrackConstraints.h */; settings = {ATTRIBUTES = (Private, ); }; };
    25502551                932CC0D51DFFD667004C0F9F /* JSMediaTrackConstraints.h in Headers */ = {isa = PBXBuildFile; fileRef = 932CC0D11DFFD667004C0F9F /* JSMediaTrackConstraints.h */; };
    … …  
    1040710408                931CBD0B161A44E900E4C874 /* ScrollingStateTree.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollingStateTree.h; sourceTree = "<group>"; };
    1040810409                931D72F515FE695300C4C07E /* LayoutMilestone.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LayoutMilestone.h; sourceTree = "<group>"; };
     10410                9323B06D23061E9B00901C8B /* IDBSerializationContext.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = IDBSerializationContext.cpp; sourceTree = "<group>"; };
     10411                9323B06F23061E9C00901C8B /* IDBSerializationContext.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = IDBSerializationContext.h; sourceTree = "<group>"; };
    1040910412                9327A94109968D1A0068A546 /* HTMLOptionsCollection.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = HTMLOptionsCollection.cpp; sourceTree = "<group>"; };
    1041010413                932CC0B61DFFD158004C0F9F /* MediaTrackConstraints.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MediaTrackConstraints.h; sourceTree = "<group>"; };
    … …  
    1855618559                        isa = PBXGroup;
    1855718560                        children = (
     18561                                9323B06D23061E9B00901C8B /* IDBSerializationContext.cpp */,
     18562                                9323B06F23061E9C00901C8B /* IDBSerializationContext.h */,
    1855818563                                51BA4AC71BBC5AD600DF3D6D /* IDBBackingStore.h */,
    1855918564                                516D7D6D1BB5F06500AF7C77 /* IDBConnectionToClient.cpp */,
    … …  
    3000530010                                1AE2AA980A1CDD2D00B42B25 /* JSHTMLImageElement.h in Headers */,
    3000630011                                A80E7E970A1A83E3007FB8C5 /* JSHTMLInputElement.h in Headers */,
     30012                                9323B07023061F9700901C8B /* IDBSerializationContext.h in Headers */,
    3000730013                                836B09561F5F34D9003C3702 /* JSHTMLInputElementEntriesAPI.h in Headers */,
    3000830014                                A6148A7912E41E3B0044A784 /* JSHTMLKeygenElement.h in Headers */,
Note: See TracChangeset for help on using the changeset viewer.