Wrap large IndexedDB values into Blobs before writing to LevelDB.

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

Index: third_party/WebKit/Source/modules/indexeddb/IDBRequestQueue.cpp
diff --git a/third_party/WebKit/Source/modules/indexeddb/IDBRequestQueue.cpp b/third_party/WebKit/Source/modules/indexeddb/IDBRequestQueue.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..da2c63647251fc4a1d7ba4903eec04488b070e66
--- /dev/null
+++ b/third_party/WebKit/Source/modules/indexeddb/IDBRequestQueue.cpp
@@ -0,0 +1,141 @@
+
+// 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/IDBRequestQueue.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 "public/platform/modules/indexeddb/WebIDBCursor.h"
+
+namespace blink {
+
+IDBRequestQueueItem::IDBRequestQueueItem(IDBRequest* request,
+                                         DOMException* error)
+    : request_(request), error_(error), mode_(kError) {}
+
+IDBRequestQueueItem::IDBRequestQueueItem(IDBRequest* request, IDBKey* key)
+    : request_(request), key_(key), mode_(kKey) {}
+
+IDBRequestQueueItem::IDBRequestQueueItem(IDBRequest* request,
+                                         PassRefPtr<IDBValue> value)
+    : request_(request), mode_(kValue) {
+  values_.push_back(std::move(value));
+}
+
+IDBRequestQueueItem::IDBRequestQueueItem(IDBRequest* request,
+                                         const Vector<RefPtr<IDBValue>>& values)
+    : request_(request), values_(values), mode_(kValueArray) {}
+
+IDBRequestQueueItem::IDBRequestQueueItem(IDBRequest* request,
+                                         IDBKey* key,
+                                         IDBKey* primary_key,
+                                         PassRefPtr<IDBValue> value)
+    : request_(request),
+      key_(key),
+      primary_key_(primary_key),
+      mode_(kKeyPrimaryKeyValue) {
+  values_.push_back(std::move(value));
+}
+
+IDBRequestQueueItem::IDBRequestQueueItem(IDBRequest* request,
+                                         std::unique_ptr<WebIDBCursor> backend,
+                                         IDBKey* key,
+                                         IDBKey* primary_key,
+                                         PassRefPtr<IDBValue> value)
+    : request_(request),
+      key_(key),
+      primary_key_(primary_key),
+      backend_(std::move(backend)),
+      mode_(kBackendKeyPrimaryKeyValue) {
+  values_.push_back(std::move(value));
+}
+
+void IDBRequestQueueItem::MarkReady() {
+  DCHECK(!ready_);
+  ready_ = true;
+
+  request_->transaction()->OnResultReady();
+}
+
+void IDBRequestQueueItem::MarkReady(DOMException* error) {
+  DCHECK(!ready_);
+  DCHECK(mode_ != kError);
+
+  mode_ = kError;
+  error_ = error;
+
+  // This is not necessary, but releases non-trivial amounts of memory early.
+  values_.clear();
+
+  MarkReady();
+}
+
+void IDBRequestQueueItem::AttachLoader() {
+  DCHECK(!loader_);
+  DCHECK(!values_.IsEmpty());
+  DCHECK(IDBRequestLoader::NeedUnwrapping(values_));
+
+  ready_ = false;
+  loader_ = new IDBRequestLoader(this, &values_);

[dmurph, 2017/05/04 22:27:07]

The loader will definitely be only loading one blob, right? or, one value,
right? Or I guess it could be wrapping a list of values - is that more accurate?

[pwnall, 2017/05/11 23:54:24]

IDBObjectStore.getAll() returns an array of IDBValues, so the loader needs to
potentially unwrap multiple values in that case. To make my life easier, I made
the loader work with a vector, and the vector just happens to have exactly one
value for many overloads.

There are two questions here that you might be implicitly asking.

1) Is the vector overload negligible, compared to blob-unwrapping?
I think so, but I haven't checked.

2) Would it make sense to unwrap values in parallel, rather than sequentially?
Maybe. We'd need a global queue, to make sure we don't unwrap a million blobs at
the same time. The queue might already exist in FileReader, because it needs
throttling against script abuse, anyway. Even if we want parallel reading, it
seems like a great candidate for a follow-up CL.

+}
+
+void IDBRequestQueueItem::StartLoading() {
+  if (loader_) {
+    DCHECK(!ready_);
+    loader_->Start();
+  }
+}
+
+void IDBRequestQueueItem::FireCallback() {
+#if DCHECK_IS_ON()
+  DCHECK(ready_);
+  DCHECK(!callback_fired_);
+  callback_fired_ = true;
+#endif  // DCHECK_IS_ON()
+
+  switch (mode_) {
+    case kError:
+      DCHECK(error_);
+      request_->OnError(error_);
+      break;
+
+    case kBackendKeyPrimaryKeyValue:
+      DCHECK_EQ(values_.size(), 1U);
+      request_->OnSuccess(std::move(backend_), key_, primary_key_,
+                          std::move(values_.front()));
+      break;
+
+    case kKeyPrimaryKeyValue:
+      DCHECK_EQ(values_.size(), 1U);
+      request_->OnSuccess(key_, primary_key_, std::move(values_.front()));
+      break;
+
+    case kKey:
+      request_->OnSuccess(key_);
+      break;
+
+    case kValue:
+      DCHECK_EQ(values_.size(), 1U);
+      request_->OnSuccess(std::move(values_.front()));
+      break;
+
+    case kValueArray:
+      request_->OnSuccess(values_);
+      break;
+  }
+}
+
+DEFINE_TRACE(IDBRequestQueueItem) {
+  visitor->Trace(error_);
+  visitor->Trace(loader_);
+  visitor->Trace(request_);
+  visitor->Trace(key_);
+  visitor->Trace(primary_key_);
+}
+
+}  // namespace blink