Blob support for IDB [Blink]

Source/modules/indexeddb/IDBObjectStore.cpp

 /*
  * Copyright (C) 2010 Google 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
@@ skipping 145 matching lines @@
         es.throwDOMException(TransactionInactiveError, IDBDatabase::transactionInactiveErrorMessage);
         return 0;
     }
     if (m_transaction->isReadOnly()) {
         es.throwDOMException(ReadOnlyError);
         return 0;
     }
 
     // FIXME: Make serialize etc take an ExceptionState or use ScriptState::setDOMException.
     bool didThrow = false;
-    RefPtr<SerializedScriptValue> serializedValue = value.serialize(state, 0, 0, didThrow);
+    Vector<BlobInfo> blobInfo;
+    RefPtr<SerializedScriptValue> serializedValue = value.serialize(state, &blobInfo, didThrow);
+    ASSERT(serializedValue->blobInfo() == &blobInfo);
     if (didThrow)
         return 0;
 
-    if (serializedValue->blobURLs().size() > 0) {
-        // FIXME: Add Blob/File/FileList support
-        es.throwDOMException(DataCloneError);
-        return 0;
-    }
-
     const IDBKeyPath& keyPath = m_metadata.keyPath;
     const bool usesInLineKeys = !keyPath.isNull();
     const bool hasKeyGenerator = autoIncrement();
 
     ScriptExecutionContext* context = state->scriptExecutionContext();
     DOMRequestState requestState(context);
 
     if (putMode != IDBDatabaseBackendInterface::CursorUpdate && usesInLineKeys && key) {
         es.throwDOMException(DataError, "The object store uses in-line keys and the key parameter was provided.");
         return 0;
@@ skipping 32 matching lines @@
         IndexKeys keys;
         generateIndexKeysForValue(&requestState, it->value, value, &keys);
         indexIds.append(it->key);
         indexKeys.append(keys);
     }
 
     RefPtr<IDBRequest> request = IDBRequest::create(context, source, m_transaction.get());
     Vector<char> wireBytes;
     serializedValue->toWireBytes(wireBytes);
     RefPtr<SharedBuffer> valueBuffer = SharedBuffer::adoptVector(wireBytes);
-    backendDB()->put(m_transaction->id(), id(), valueBuffer, key.release(), static_cast<IDBDatabaseBackendInterface::PutMode>(putMode), request, indexIds, indexKeys);
+    backendDB()->put(m_transaction->id(), id(), valueBuffer, serializedValue->blobInfo(), key.release(), static_cast<IDBDatabaseBackendInterface::PutMode>(putMode), request, indexIds, indexKeys);

[jsbell, 2013/09/12 22:52:17]

If we remove m_blobInfo from SSV, this can just the the local &blobInfo; to me
that's clearer since we've already asked the SSV to dump the blob metadata into
our local stash.

[ericu, 2013/11/20 23:06:08]

Done.

+    // TODO(ericu): Hold a reference to each blob in serializedValue->blobInfo()

[jsbell, 2013/09/12 22:52:17]

Adding a vector of blob refs to IDBTransaction sounds fine. The IDBRequest
itself may be collected earlier.

[ericu, 2013/11/20 23:06:08]

Updated TODO.

+    // until the transaction's committed or this value is overwritten or
+    // otherwise removed. We have to grab it here, rather than the backend, to
+    // avoid a race. Blobs live on the IO thread in the backend, and IDB
+    // requests are handled on the IDB task runner; if we grabbed the blob
+    // references on the IO thread before switching to the IDB task runner, that
+    // would work too, but it's probably safer to have the refs held in the
+    // renderer, in case of crashes, request failures, etc.
     return request.release();
 }
 
 PassRefPtr<IDBRequest> IDBObjectStore::deleteFunction(ScriptExecutionContext* context, const ScriptValue& key, ExceptionState& es)
 {
     IDB_TRACE("IDBObjectStore::delete");
     if (isDeleted()) {
         es.throwDOMException(InvalidStateError, IDBDatabase::objectStoreDeletedErrorMessage);
         return 0;
     }
@@ skipping 89 matching lines @@
 
         Vector<int64_t, 1> indexIds;
         indexIds.append(m_indexMetadata.id);
         if (cursor) {
             cursor->continueFunction(static_cast<IDBKey*>(0), ASSERT_NO_EXCEPTION);
 
             RefPtr<IDBKey> primaryKey = cursor->idbPrimaryKey();
             ScriptValue value = cursor->value(context);
 
             IDBObjectStore::IndexKeys indexKeys;
             generateIndexKeysForValue(request->requestState(), m_indexMetadata, value, &indexKeys);

[jsbell, 2013/09/12 22:52:17]

Although it's not obvious in the spec, this needs to handle a few Blob/File
properties:

https://dvcs.w3.org/hg/IndexedDB/raw-file/tip/Overview.html#key-path-construct

The scenario is that data containing Blobs already exists in a store. A new
index is created store.createIndex("mime-type-index", "blob.type");

When creating the index, this class will be used to fetch the records to index
them. We should ensure we're getting back the Blob metadata (which should be in
the serialized value) and that we can deserialize the SSV (which happens in the
IDBRequest which invokes this), but that we're not doing too much extra work
since the blob data itself will never be used here.

[ericu, 2013/11/20 23:06:08]

Ah, I hadn't noticed that the blob properties were fair game for indexing. 
We'll have to talk about this some more.  I've got the metadata on the browser
side already, I just need to understand where I need to pipe it.

[ericu, 2013/11/26 00:26:14]

OK, I was confused--this is all taking place on the client side, using cursors
to pull out the data.  It should all just work already.

 
             Vector<IDBObjectStore::IndexKeys, 1> indexKeysList;
             indexKeysList.append(indexKeys);
 
             m_databaseBackend->setIndexKeys(m_transactionId, m_objectStoreId, primaryKey, indexIds, indexKeysList);
         } else {
             // Now that we are done indexing, tell the backend to go
             // back to processing tasks of type NormalTask.
             m_databaseBackend->setIndexesReady(m_transactionId, m_objectStoreId, indexIds);
             m_databaseBackend.clear();
@@ skipping 233 matching lines @@
     }
     return IDBIndexMetadata::InvalidId;
 }
 
 IDBDatabaseBackendInterface* IDBObjectStore::backendDB() const
 {
     return m_transaction->backendDB();
 }
 
 } // namespace WebCore