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..d001b74c99e915bd59470607411c1d89b474d4fb
--- /dev/null
+++ b/third_party/WebKit/Source/modules/indexeddb/IDBRequestQueueItem.h
@@ -0,0 +1,151 @@
+// 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/Allocator.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 {
+  USING_FAST_MALLOC(IDBRequestQueueItem);
+
+ public:
+  IDBRequestQueueItem(IDBRequest*, DOMException*);

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

I'd love to remove IDBRequest from the class all together and instead use
callbacks - I'm not sure if that's possible though. But I think it's doable.

There would be two callbacks, one for the transactions OnResultsReady - which I
would rename to SendAvailableResponses (something a little more descriptive of
what it does).

The second would be to enqueue the response. Couldn't we wrap the values we're
giving in the constructor in a closure that calls EnqueueReponse on the request?

Then we remove the dependencies on the request and the transaction (yes we
remove the dcheck - I'm fine with that, or we can do checking some other way -
like in one of the callbacks). 

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

This is not straightforward because some of the values in the callback are
replaced by post-processing. Specifically, the IDBValues in PassRefPtr<IDBValue>
and Vector<RefPtr<IDBValue>> can change if they're

How about we refactor this after it lands successfully? It'll be easier to
reason about the code impact of callbacks.

[dmurph, 2017/05/25 17:28:06]

sgtm

+  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>,
+                      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();
+
+  // Stops post-processing the IDBRequest's result.
+  //
+  // This method may be called without an associated StartLoading().
+  void CancelLoading();
+
+  // Calls the correct EnqueueResponse overload on the associated request.
+  //
+  // This should only be called by the request's IDBTransaction.
+  void EnqueueResponse();
+
+  // Called by the associated IDBRequestLoader when result processing is done.
+  void OnResultLoadComplete();
+
+  // Called by the associated IDBRequestLoader when result processing fails.
+  void OnResultLoadComplete(DOMException* error);
+
+ private:
+  // The IDBRequest callback that will be called for this result.
+  enum ResponseType {
+    kCursorKeyPrimaryKeyValue,
+    kError,
+    kNumber,
+    kKey,
+    kKeyPrimaryKeyValue,
+    kValue,
+    kValueArray,
+    kVoid,
+  };
+
+  // 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 cursor argument to the IDBRequest callback.
+  std::unique_ptr<WebIDBCursor> cursor_;
+
+  // 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_;
+
+  // Identifies the IDBRequest::EnqueueResponse() overload that will be called.
+  ResponseType response_type_;
+
+  // 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