Add the backchannel for Blobs to be received into Blink from the database backend.

Source/modules/indexeddb/IDBRequest.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 21 matching lines @@
 #include "bindings/v8/ExceptionState.h"
 #include "bindings/v8/ExceptionStatePlaceholder.h"
 #include "bindings/v8/IDBBindingUtilities.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/events/EventQueue.h"
 #include "modules/indexeddb/IDBCursorWithValue.h"
 #include "modules/indexeddb/IDBDatabase.h"
 #include "modules/indexeddb/IDBEventDispatcher.h"
 #include "modules/indexeddb/IDBTracing.h"
 #include "platform/SharedBuffer.h"
+#include "public/platform/WebBlobInfo.h"
 
 using blink::WebIDBCursor;
 
 namespace WebCore {
 
 PassRefPtrWillBeRawPtr<IDBRequest> IDBRequest::create(ExecutionContext* context, PassRefPtrWillBeRawPtr<IDBAny> source, IDBTransaction* transaction)
 {
     RefPtrWillBeRawPtr<IDBRequest> request(adoptRefWillBeRefCountedGarbageCollected(new IDBRequest(context, source, transaction)));
     request->suspendIfNeeded();
     // Requests associated with IDBFactory (open/deleteDatabase/getDatabaseNames) are not associated with transactions.
@@ skipping 17 matching lines @@
     , m_didFireUpgradeNeededEvent(false)
     , m_preventPropagation(false)
     , m_resultDirty(true)
 {
     ScriptWrappable::init(this);
 }
 
 IDBRequest::~IDBRequest()
 {
     ASSERT(m_readyState == DONE || m_readyState == EarlyDeath || !executionContext());
+    handleBlobAcks();
 }
 
 void IDBRequest::trace(Visitor* visitor)
 {
     visitor->trace(m_source);
     visitor->trace(m_result);
     visitor->trace(m_error);
     visitor->trace(m_enqueuedEvents);
     visitor->trace(m_pendingCursor);
 }
 
 ScriptValue IDBRequest::result(ExceptionState& exceptionState)
 {
     if (m_readyState != DONE) {
         exceptionState.throwDOMException(InvalidStateError, IDBDatabase::requestNotFinishedErrorMessage);
         return ScriptValue();
     }
     if (m_contextStopped || !executionContext())
         return ScriptValue();
     m_resultDirty = false;
-    return idbAnyToScriptValue(m_scriptState.get(), m_result);
+    ScriptValue value = idbAnyToScriptValue(m_scriptState.get(), m_result);
+    handleBlobAcks();
+    return value;
 }
 
 PassRefPtrWillBeRawPtr<DOMError> IDBRequest::error(ExceptionState& exceptionState) const
 {
     if (m_readyState != DONE) {
         exceptionState.throwDOMException(InvalidStateError, IDBDatabase::requestNotFinishedErrorMessage);
         return nullptr;
     }
     return m_error;
 }
@@ skipping 71 matching lines @@
 {
     if (!m_result)
         return 0;
     if (m_result->type() == IDBAny::IDBCursorType)
         return m_result->idbCursor();
     if (m_result->type() == IDBAny::IDBCursorWithValueType)
         return m_result->idbCursorWithValue();
     return 0;
 }
 
-void IDBRequest::setResultCursor(PassRefPtrWillBeRawPtr<IDBCursor> cursor, PassRefPtr<IDBKey> key, PassRefPtr<IDBKey> primaryKey, PassRefPtr<SharedBuffer> value)
+void IDBRequest::setResultCursor(PassRefPtrWillBeRawPtr<IDBCursor> cursor, PassRefPtr<IDBKey> key, PassRefPtr<IDBKey> primaryKey, PassRefPtr<SharedBuffer> value, PassOwnPtr<Vector<blink::WebBlobInfo> > blobInfo)
 {
     ASSERT(m_readyState == PENDING);
     m_cursorKey = key;
     m_cursorPrimaryKey = primaryKey;
     m_cursorValue = value;
+    ASSERT(!m_blobInfo.get());
+    m_blobInfo = blobInfo;
 
     onSuccessInternal(IDBAny::create(cursor));
 }
 
 #if !ENABLE(OILPAN)
 void IDBRequest::checkForReferenceCycle()
 {
     // If this request and its cursor have the only references
     // to each other, then explicitly break the cycle.
     IDBCursor* cursor = getResultCursor();
     if (!cursor || cursor->request() != this)
         return;
 
     if (!hasOneRef() || !cursor->hasOneRef())
         return;
 
     m_result.clear();
 }
 #endif
 
+void IDBRequest::handleBlobAcks()
+{
+    if (m_blobInfo.get() && m_blobInfo->size()) {
+        m_transaction->db()->ackReceivedBlobs(m_blobInfo.get());
+        m_blobInfo.clear();
+    }
+}
+
 bool IDBRequest::shouldEnqueueEvent() const
 {
     if (m_contextStopped || !executionContext())
         return false;
     ASSERT(m_readyState == PENDING || m_readyState == DONE);
     if (m_requestAborted)
         return false;
     ASSERT(m_readyState == PENDING);
     ASSERT(!m_error && !m_result);
     return true;
@@ skipping 15 matching lines @@
     IDB_TRACE("IDBRequest::onSuccess(StringList)");
     if (!shouldEnqueueEvent())
         return;
 
     RefPtr<DOMStringList> domStringList = DOMStringList::create();
     for (size_t i = 0; i < stringList.size(); ++i)
         domStringList->append(stringList[i]);
     onSuccessInternal(IDBAny::create(domStringList.release()));
 }
 
-void IDBRequest::onSuccess(PassOwnPtr<blink::WebIDBCursor> backend, PassRefPtr<IDBKey> key, PassRefPtr<IDBKey> primaryKey, PassRefPtr<SharedBuffer> value)
+void IDBRequest::onSuccess(PassOwnPtr<blink::WebIDBCursor> backend, PassRefPtr<IDBKey> key, PassRefPtr<IDBKey> primaryKey, PassRefPtr<SharedBuffer> value, PassOwnPtr<Vector<blink::WebBlobInfo> > blobInfo)
 {
     IDB_TRACE("IDBRequest::onSuccess(IDBCursor)");
     if (!shouldEnqueueEvent())
         return;
 
     ASSERT(!m_pendingCursor);
     RefPtrWillBeRawPtr<IDBCursor> cursor = nullptr;
     switch (m_cursorType) {
     case IndexedDB::CursorKeyOnly:
         cursor = IDBCursor::create(backend, m_cursorDirection, this, m_source.get(), m_transaction.get());
         break;
     case IndexedDB::CursorKeyAndValue:
         cursor = IDBCursorWithValue::create(backend, m_cursorDirection, this, m_source.get(), m_transaction.get());
         break;
     default:
         ASSERT_NOT_REACHED();
     }
-    setResultCursor(cursor, key, primaryKey, value);
+    setResultCursor(cursor, key, primaryKey, value, blobInfo);
 }
 
 void IDBRequest::onSuccess(PassRefPtr<IDBKey> idbKey)
 {
     IDB_TRACE("IDBRequest::onSuccess(IDBKey)");
     if (!shouldEnqueueEvent())
         return;
 
     if (idbKey && idbKey->isValid())
         onSuccessInternal(IDBAny::create(idbKey));
     else
         onSuccessInternal(IDBAny::createUndefined());
 }
 
-void IDBRequest::onSuccess(PassRefPtr<SharedBuffer> valueBuffer)
+void IDBRequest::onSuccess(PassRefPtr<SharedBuffer> valueBuffer, PassOwnPtr<Vector<blink::WebBlobInfo> > blobInfo)
 {
     IDB_TRACE("IDBRequest::onSuccess(SharedBuffer)");
     if (!shouldEnqueueEvent())
         return;
 
     if (m_pendingCursor) {
         // Value should be null, signifying the end of the cursor's range.
         ASSERT(!valueBuffer.get());
+        ASSERT(!blobInfo->size());
         m_pendingCursor->close();
         m_pendingCursor.clear();
     }
 
-    onSuccessInternal(IDBAny::create(valueBuffer));
+    ASSERT(!m_blobInfo.get());
+    m_blobInfo = blobInfo;
+    onSuccessInternal(IDBAny::create(valueBuffer, m_blobInfo.get()));
 }
 
 #ifndef NDEBUG
 static PassRefPtr<IDBObjectStore> effectiveObjectStore(PassRefPtrWillBeRawPtr<IDBAny> source)
 {
     if (source->type() == IDBAny::IDBObjectStoreType)
         return source->idbObjectStore();
     if (source->type() == IDBAny::IDBIndexType)
         return source->idbIndex()->objectStore();
 
     ASSERT_NOT_REACHED();
     return nullptr;
 }
 #endif
 
-void IDBRequest::onSuccess(PassRefPtr<SharedBuffer> prpValueBuffer, PassRefPtr<IDBKey> prpPrimaryKey, const IDBKeyPath& keyPath)
+void IDBRequest::onSuccess(PassRefPtr<SharedBuffer> prpValueBuffer, PassOwnPtr<Vector<blink::WebBlobInfo> > blobInfo, PassRefPtr<IDBKey> prpPrimaryKey, const IDBKeyPath& keyPath)
 {
     IDB_TRACE("IDBRequest::onSuccess(SharedBuffer, IDBKey, IDBKeyPath)");
     if (!shouldEnqueueEvent())
         return;
 
 #ifndef NDEBUG
     ASSERT(keyPath == effectiveObjectStore(m_source)->metadata().keyPath);
 #endif
 
     RefPtr<SharedBuffer> valueBuffer = prpValueBuffer;
     RefPtr<IDBKey> primaryKey = prpPrimaryKey;
+    ASSERT(!m_blobInfo.get());
+    m_blobInfo = blobInfo;
 
 #ifndef NDEBUG
-    assertPrimaryKeyValidOrInjectable(m_scriptState.get(), valueBuffer, primaryKey, keyPath);
+    assertPrimaryKeyValidOrInjectable(m_scriptState.get(), valueBuffer, m_blobInfo.get(), primaryKey, keyPath);
 #endif
 
-    onSuccessInternal(IDBAny::create(valueBuffer, primaryKey, keyPath));
+    onSuccessInternal(IDBAny::create(valueBuffer, m_blobInfo.get(), primaryKey, keyPath));
 }
 
 void IDBRequest::onSuccess(int64_t value)
 {
     IDB_TRACE("IDBRequest::onSuccess(int64_t)");
     if (!shouldEnqueueEvent())
         return;
     onSuccessInternal(IDBAny::create(value));
 }
 
@@ skipping 12 matching lines @@
     setResult(result);
     enqueueEvent(Event::create(EventTypeNames::success));
 }
 
 void IDBRequest::setResult(PassRefPtrWillBeRawPtr<IDBAny> result)
 {
     m_result = result;
     m_resultDirty = true;
 }
 
-void IDBRequest::onSuccess(PassRefPtr<IDBKey> key, PassRefPtr<IDBKey> primaryKey, PassRefPtr<SharedBuffer> value)
+void IDBRequest::onSuccess(PassRefPtr<IDBKey> key, PassRefPtr<IDBKey> primaryKey, PassRefPtr<SharedBuffer> value, PassOwnPtr<Vector<blink::WebBlobInfo> > blobInfo)
 {
     IDB_TRACE("IDBRequest::onSuccess(key, primaryKey, value)");
     if (!shouldEnqueueEvent())
         return;
 
     ASSERT(m_pendingCursor);
-    setResultCursor(m_pendingCursor.release(), key, primaryKey, value);
+    setResultCursor(m_pendingCursor.release(), key, primaryKey, value, blobInfo);
 }
 
 bool IDBRequest::hasPendingActivity() const
 {
     // FIXME: In an ideal world, we should return true as long as anyone has a or can
     //        get a handle to us and we have event listeners. This is order to handle
     //        user generated events properly.
     return m_hasPendingActivity && !m_contextStopped;
 }
 
@@ skipping 58 matching lines @@
         // this object to actually hold a reference to the database (to ensure
         // it stays alive).
         targets.append(m_transaction->db());
     }
 
     // Cursor properties should not be updated until the success event is being dispatched.
     RefPtrWillBeRawPtr<IDBCursor> cursorToNotify = nullptr;
     if (event->type() == EventTypeNames::success) {
         cursorToNotify = getResultCursor();
         if (cursorToNotify)
-            cursorToNotify->setValueReady(m_cursorKey.release(), m_cursorPrimaryKey.release(), m_cursorValue.release());
+            cursorToNotify->setValueReady(m_cursorKey.release(), m_cursorPrimaryKey.release(), m_cursorValue.release(), m_blobInfo.release());
     }
 
     if (event->type() == EventTypeNames::upgradeneeded) {
         ASSERT(!m_didFireUpgradeNeededEvent);
         m_didFireUpgradeNeededEvent = true;
     }
 
     // FIXME: When we allow custom event dispatching, this will probably need to change.
     ASSERT_WITH_MESSAGE(event->type() == EventTypeNames::success || event->type() == EventTypeNames::error || event->type() == EventTypeNames::blocked || event->type() == EventTypeNames::upgradeneeded, "event type was %s", event->type().utf8().data());
     const bool setTransactionActive = m_transaction && (event->type() == EventTypeNames::success || event->type() == EventTypeNames::upgradeneeded || (event->type() == EventTypeNames::error && !m_requestAborted));
@@ skipping 74 matching lines @@
 
 void IDBRequest::dequeueEvent(Event* event)
 {
     for (size_t i = 0; i < m_enqueuedEvents.size(); ++i) {
         if (m_enqueuedEvents[i].get() == event)
             m_enqueuedEvents.remove(i);
     }
 }
 
 } // namespace WebCore