Wrap large IndexedDB values into Blobs before writing to LevelDB.

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

Index: third_party/WebKit/Source/modules/indexeddb/IDBRequestQueueItem.h
diff --git a/third_party/WebKit/Source/modules/indexeddb/IDBRequestQueueItem.h b/third_party/WebKit/Source/modules/indexeddb/IDBRequestQueueItem.h
new file mode 100644
index 0000000000000000000000000000000000000000..744c1aaf0a4b1a27a7f3f29d264c7f3ad82444bb
--- /dev/null
+++ b/third_party/WebKit/Source/modules/indexeddb/IDBRequestQueueItem.h
@@ -0,0 +1,146 @@
+// 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.
+
+#ifndef IDBRequestQueueItem_h
+#define IDBRequestQueueItem_h
+
+#include "platform/heap/Handle.h"
+#include "platform/wtf/PassRefPtr.h"
+#include "platform/wtf/RefPtr.h"
+#include "platform/wtf/Vector.h"
+
+#include <memory>
+
+namespace blink {
+
+class DOMException;
+class IDBKey;
+class IDBRequest;
+class IDBRequestLoader;
+class IDBValue;
+class WebIDBCursor;
+
+// Queues up a transaction's IDBRequest results for orderly delivery.
+//
+// The IndexedDB specification requires that the events corresponding to IDB
+// request results fire in the order in which the requests were issued. The
+// browser-side backend processes requests in order, but the Blink side may need
+// to perform post-processing on the results (e.g. large value unwrapping).
+// When a result needs post-processing, this queue captures all results received
+// during the post-processing steps. The events for these results may only fire
+// after the post-processed result's event is fired.
+class IDBRequestQueueItem {
+ public:
+  IDBRequestQueueItem(IDBRequest*, DOMException*);
+  IDBRequestQueueItem(IDBRequest*, int64_t);
+  IDBRequestQueueItem(IDBRequest*);
+  IDBRequestQueueItem(IDBRequest*, IDBKey*);
+  IDBRequestQueueItem(IDBRequest*, PassRefPtr<IDBValue>, bool attach_loader);
+  IDBRequestQueueItem(IDBRequest*,
+                      const Vector<RefPtr<IDBValue>>&,
+                      bool attach_loader);
+  IDBRequestQueueItem(IDBRequest*,
+                      IDBKey*,
+                      IDBKey* primary_key,
+                      PassRefPtr<IDBValue>,
+                      bool attach_loader);
+  IDBRequestQueueItem(IDBRequest*,
+                      std::unique_ptr<WebIDBCursor> backend,
+                      IDBKey*,
+                      IDBKey* primary_key,
+                      PassRefPtr<IDBValue>,
+                      bool attach_loader);
+  ~IDBRequestQueueItem();
+
+  // False if this result still requires post-processing.
+  inline bool IsReady() { return ready_; }
+
+  // The request whose queued result is tracked by this item.
+  inline IDBRequest* Request() { return request_; }
+
+  // Starts post-processing the IDBRequest's result.
+  //
+  // This method must be called after the IDBRequestQueueItem is enqueued into
+  // the appropriate queue, because it is possible for the loading operation to
+  // complete synchronously, in which case IDBTransaction::OnResultReady() will
+  // be called with the (presumably) enqueued IDBRequest before this method
+  // returns.
+  void StartLoading();
+
+  // Calls the correct overload of OnSuccess/OnError on the associated request.
+  //
+  // This should only be called by the request's IDBTransaction.
+  void FireCallback();

[jsbell, 2017/05/15 23:37:38]

Nit about naming: 'Fire' has a specific DOM meaning - synchronous event
dispatch. So we should avoid that term here since this really causes an event to
be enqueued.

[pwnall, 2017/05/19 18:27:35]

Done.
Renamed to EnqueueResponse(), to match the method name in IDBRequest.

+
+  // Marks the result as having being post-processed.
+  //
+  // This method should only be called by the associated IDBRequestLoader.
+  void MarkReady();
+  // Called when an error occurs during result post-processing.
+  //
+  // This method should only be called by the associated IDBRequestLoader.
+  void MarkReady(DOMException* error);
+
+ private:
+  // The IDBRequest callback that will be called for this result.
+  enum Mode {

[jsbell, 2017/05/15 23:37:38]

Since 'mode' is a spec term/IDL enum (for transaction mode), maybe ResponseType
?

[pwnall, 2017/05/19 18:27:35]

Done.

+    kBackendKeyPrimaryKeyValue,

[jsbell, 2017/05/15 23:37:38]

I'd call this kCursorKeyPrimaryKeyValue

[pwnall, 2017/05/19 18:27:35]

Done.

+    kError,
+    kInt64Value,

[jsbell, 2017/05/15 23:37:38]

kNumber ?

[pwnall, 2017/05/19 18:27:34]

Done.

+    kKey,
+    kKeyPrimaryKeyValue,
+    kNoArguments,

[jsbell, 2017/05/15 23:37:38]

kVoid ? 

[pwnall, 2017/05/19 18:27:34]

Done.

+    kValue,
+    kValueArray,
+  };
+
+  // The IDBRequest that will receive a callback for this result.
+  Persistent<IDBRequest> request_;
+
+  // The key argument to the IDBRequest callback.
+  //
+  // Only used if mode_ is kKeyPrimaryKeyValue.
+  Persistent<IDBKey> key_;
+
+  // The primary_key argument to the IDBRequest callback.
+  //
+  // Only used if mode_ is kKeyPrimaryKeyValue.
+  Persistent<IDBKey> primary_key_;
+
+  // The error argument to the IDBRequest callback.
+  //
+  // Only used if the mode_ is kError.
+  Persistent<DOMException> error_;
+
+  // All the values that will be passed back to the IDBRequest.
+  Vector<RefPtr<IDBValue>> values_;
+
+  // The backend argument to the IDBRequest callback.
+  std::unique_ptr<WebIDBCursor> backend_;

[jsbell, 2017/05/15 23:37:38]

'cursor' instead of 'backend' here?

[pwnall, 2017/05/19 18:27:35]

Done.

+
+  // Performs post-processing on this result.
+  //
+  // nullptr for results that do not require post-processing and for results
+  // whose post-processing has completed.
+  std::unique_ptr<IDBRequestLoader> loader_;
+
+  // The integer value argument to the IDBRequest callback.
+  int64_t int64_value_;
+
+  // The IDBRequest callback that will be called for this result.
+  Mode mode_;
+
+  // False if this result still requires post-processing.
+  bool ready_;
+
+#if DCHECK_IS_ON()
+  bool callback_fired_ = false;
+#endif  // DCHECK_IS_ON()
+};
+
+using IDBRequestQueue = Deque<std::unique_ptr<IDBRequestQueueItem>>;
+
+}  // namespace blink
+
+#endif  // IDBRequestQueueItem_h