Wrap large IndexedDB values into Blobs before writing to LevelDB.

third_party/WebKit/Source/modules/indexeddb/IDBRequestQueueItem.cpp

Index: third_party/WebKit/Source/modules/indexeddb/IDBRequestQueueItem.cpp
diff --git a/third_party/WebKit/Source/modules/indexeddb/IDBRequestQueueItem.cpp b/third_party/WebKit/Source/modules/indexeddb/IDBRequestQueueItem.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5aad0fe803a54d3cf5c1ba82b57711d5090491cb
--- /dev/null
+++ b/third_party/WebKit/Source/modules/indexeddb/IDBRequestQueueItem.cpp
@@ -0,0 +1,216 @@
+
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "modules/indexeddb/IDBRequestQueueItem.h"
+
+#include "core/dom/DOMException.h"
+#include "modules/indexeddb/IDBKey.h"
+#include "modules/indexeddb/IDBRequest.h"
+#include "modules/indexeddb/IDBRequestLoader.h"
+#include "modules/indexeddb/IDBValue.h"
+#include "platform/wtf/PtrUtil.h"
+#include "public/platform/modules/indexeddb/WebIDBCursor.h"
+
+namespace blink {
+
+IDBRequestQueueItem::IDBRequestQueueItem(IDBRequest* request,
+                                         DOMException* error)
+    : request_(request), error_(error), response_type_(kError), ready_(true) {
+#if DCHECK_IS_ON()
+  DCHECK_EQ(request->queue_item_, nullptr);
+  request_->queue_item_ = this;
+#endif  // DCHECK_IS_ON()
+}
+
+IDBRequestQueueItem::IDBRequestQueueItem(IDBRequest* request, int64_t value)
+    : request_(request),
+      int64_value_(value),
+      response_type_(kNumber),
+      ready_(true) {
+#if DCHECK_IS_ON()
+  DCHECK_EQ(request->queue_item_, nullptr);
+  request_->queue_item_ = this;
+#endif  // DCHECK_IS_ON()
+}
+
+IDBRequestQueueItem::IDBRequestQueueItem(IDBRequest* request)
+    : request_(request), response_type_(kVoid), ready_(true) {
+#if DCHECK_IS_ON()
+  DCHECK_EQ(request->queue_item_, nullptr);
+  request_->queue_item_ = this;
+#endif  // DCHECK_IS_ON()
+}
+
+IDBRequestQueueItem::IDBRequestQueueItem(IDBRequest* request, IDBKey* key)
+    : request_(request), key_(key), response_type_(kKey), ready_(true) {
+#if DCHECK_IS_ON()
+  DCHECK_EQ(request->queue_item_, nullptr);
+  request_->queue_item_ = this;
+#endif  // DCHECK_IS_ON()
+}
+
+IDBRequestQueueItem::IDBRequestQueueItem(IDBRequest* request,
+                                         PassRefPtr<IDBValue> value,
+                                         bool attach_loader)
+    : request_(request), response_type_(kValue), ready_(!attach_loader) {
+#if DCHECK_IS_ON()
+  DCHECK_EQ(request->queue_item_, nullptr);
+  request_->queue_item_ = this;
+#endif  // DCHECK_IS_ON()
+  values_.push_back(std::move(value));
+  if (attach_loader)
+    loader_ = WTF::MakeUnique<IDBRequestLoader>(this, &values_);
+}
+
+IDBRequestQueueItem::IDBRequestQueueItem(IDBRequest* request,
+                                         const Vector<RefPtr<IDBValue>>& values,
+                                         bool attach_loader)
+    : request_(request),
+      values_(values),
+      response_type_(kValueArray),
+      ready_(!attach_loader) {
+#if DCHECK_IS_ON()
+  DCHECK_EQ(request->queue_item_, nullptr);
+  request_->queue_item_ = this;
+#endif  // DCHECK_IS_ON()
+  if (attach_loader)
+    loader_ = WTF::MakeUnique<IDBRequestLoader>(this, &values_);
+}
+
+IDBRequestQueueItem::IDBRequestQueueItem(IDBRequest* request,
+                                         IDBKey* key,
+                                         IDBKey* primary_key,
+                                         PassRefPtr<IDBValue> value,
+                                         bool attach_loader)
+    : request_(request),
+      key_(key),
+      primary_key_(primary_key),
+      response_type_(kKeyPrimaryKeyValue),
+      ready_(!attach_loader) {
+#if DCHECK_IS_ON()
+  DCHECK_EQ(request->queue_item_, nullptr);
+  request_->queue_item_ = this;
+#endif  // DCHECK_IS_ON()
+  values_.push_back(std::move(value));
+  if (attach_loader)
+    loader_ = WTF::MakeUnique<IDBRequestLoader>(this, &values_);
+}
+
+IDBRequestQueueItem::IDBRequestQueueItem(IDBRequest* request,
+                                         std::unique_ptr<WebIDBCursor> cursor,
+                                         IDBKey* key,
+                                         IDBKey* primary_key,
+                                         PassRefPtr<IDBValue> value,
+                                         bool attach_loader)
+    : request_(request),
+      key_(key),
+      primary_key_(primary_key),
+      cursor_(std::move(cursor)),
+      response_type_(kCursorKeyPrimaryKeyValue),
+      ready_(!attach_loader) {
+#if DCHECK_IS_ON()
+  DCHECK_EQ(request->queue_item_, nullptr);
+  request_->queue_item_ = this;
+#endif  // DCHECK_IS_ON()
+  values_.push_back(std::move(value));
+  if (attach_loader)
+    loader_ = WTF::MakeUnique<IDBRequestLoader>(this, &values_);
+}
+
+IDBRequestQueueItem::~IDBRequestQueueItem() {
+#if DCHECK_IS_ON()
+  DCHECK(ready_);
+  DCHECK(callback_fired_);
+#endif  // DCHECK_IS_ON()
+}
+
+void IDBRequestQueueItem::OnResultLoadComplete() {
+  DCHECK(!ready_);
+  ready_ = true;
+
+  request_->transaction()->OnResultReady();

[dmurph, 2017/05/23 18:16:39]

This would be calling a callback - so we don't depend on IDBTransaction.h

[pwnall, 2017/05/25 13:27:11]

I don't think there's general callback support in Blink -- the closest I could
find is VoidCallback [1], which is garbage-collected, and seems overkill for
this case.

[1]
https://cs.chromium.org/chromium/src/third_party/WebKit/Source/core/html/Void...

+}
+
+void IDBRequestQueueItem::OnResultLoadComplete(DOMException* error) {
+  DCHECK(!ready_);
+  DCHECK(response_type_ != kError);
+
+  response_type_ = kError;
+  error_ = error;
+
+  // This is not necessary, but releases non-trivial amounts of memory early.
+  values_.clear();
+
+  OnResultLoadComplete();
+}
+
+void IDBRequestQueueItem::StartLoading() {
+  if (loader_) {
+    DCHECK(!ready_);
+    loader_->Start();
+  }
+}
+
+void IDBRequestQueueItem::CancelLoading() {
+  if (loader_ && !ready_) {
+    loader_->Cancel();
+    loader_ = nullptr;
+  }
+}
+
+void IDBRequestQueueItem::EnqueueResponse() {
+#if DCHECK_IS_ON()
+  DCHECK(ready_);
+  DCHECK(!callback_fired_);
+  callback_fired_ = true;
+
+  DCHECK_EQ(request_->queue_item_, this);
+  request_->queue_item_ = nullptr;
+#endif  // DCHECK_IS_ON()
+
+  switch (response_type_) {
+    case kCursorKeyPrimaryKeyValue:
+      DCHECK_EQ(values_.size(), 1U);
+      request_->EnqueueResponse(std::move(cursor_), key_, primary_key_,
+                                std::move(values_.front()));
+      break;
+
+    case kError:
+      DCHECK(error_);
+      request_->EnqueueResponse(error_);
+      break;
+
+    case kKeyPrimaryKeyValue:
+      DCHECK_EQ(values_.size(), 1U);
+      request_->EnqueueResponse(key_, primary_key_, std::move(values_.front()));
+      break;
+
+    case kKey:
+      DCHECK_EQ(values_.size(), 0U);
+      request_->EnqueueResponse(key_);
+      break;
+
+    case kNumber:
+      DCHECK_EQ(values_.size(), 0U);
+      request_->EnqueueResponse(int64_value_);
+      break;
+
+    case kValue:
+      DCHECK_EQ(values_.size(), 1U);
+      request_->EnqueueResponse(std::move(values_.front()));
+      break;
+
+    case kValueArray:
+      request_->EnqueueResponse(values_);
+      break;
+
+    case kVoid:
+      DCHECK_EQ(values_.size(), 0U);
+      request_->EnqueueResponse();
+      break;
+  }
+}
+
+}  // namespace blink