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_);
+}
+
+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