Wrap large IndexedDB values into Blobs before writing to LevelDB.

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

Index: third_party/WebKit/Source/modules/indexeddb/IDBRequest.cpp
diff --git a/third_party/WebKit/Source/modules/indexeddb/IDBRequest.cpp b/third_party/WebKit/Source/modules/indexeddb/IDBRequest.cpp
index fa26ce6c5aeeaf29190819da5069c7ecd8c15c20..c9f3326f31cb5ecdc7216e8b8732cfa39c1d4007 100644
--- a/third_party/WebKit/Source/modules/indexeddb/IDBRequest.cpp
+++ b/third_party/WebKit/Source/modules/indexeddb/IDBRequest.cpp
@@ -29,6 +29,8 @@
 #include "modules/indexeddb/IDBRequest.h"
 
 #include <memory>
+#include <utility>
+
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ToV8ForCore.h"
 #include "bindings/modules/v8/ToV8ForModules.h"
@@ -41,10 +43,13 @@
 #include "modules/indexeddb/IDBCursorWithValue.h"
 #include "modules/indexeddb/IDBDatabase.h"
 #include "modules/indexeddb/IDBEventDispatcher.h"
+#include "modules/indexeddb/IDBRequestQueueItem.h"
 #include "modules/indexeddb/IDBTracing.h"
 #include "modules/indexeddb/IDBValue.h"
+#include "modules/indexeddb/IDBValueWrapping.h"
 #include "modules/indexeddb/WebIDBCallbacksImpl.h"
 #include "platform/SharedBuffer.h"
+#include "platform/wtf/PtrUtil.h"
 #include "public/platform/WebBlobInfo.h"
 
 using blink::WebIDBCursor;
@@ -200,7 +205,7 @@ IDBCursor* IDBRequest::GetResultCursor() const {
 void IDBRequest::SetResultCursor(IDBCursor* cursor,
                                  IDBKey* key,
                                  IDBKey* primary_key,
-                                 PassRefPtr<IDBValue> value) {
+                                 RefPtr<IDBValue>&& value) {
   DCHECK_EQ(ready_state_, PENDING);
   cursor_key_ = key;
   cursor_primary_key_ = primary_key;
@@ -234,9 +239,85 @@ bool IDBRequest::ShouldEnqueueEvent() const {
   return true;
 }
 
+void IDBRequest::HandleResponse(DOMException* error) {
+  transit_blob_handles_.clear();
+  if (!transaction_ || !transaction_->HasQueuedResults())
+    return EnqueueResponse(error);
+  transaction_->EnqueueResult(
+      WTF::MakeUnique<IDBRequestQueueItem>(this, error));
+}
+
+void IDBRequest::HandleResponse(IDBKey* key) {
+  transit_blob_handles_.clear();
+  DCHECK(transaction_);
+  if (!transaction_->HasQueuedResults())
+    return EnqueueResponse(key);
+  transaction_->EnqueueResult(WTF::MakeUnique<IDBRequestQueueItem>(this, key));
+}
+
+void IDBRequest::HandleResponse(int64_t value_or_old_version) {
+  transit_blob_handles_.clear();
+  if (!transaction_ || !transaction_->HasQueuedResults())
+    return EnqueueResponse(value_or_old_version);
+  transaction_->EnqueueResult(
+      WTF::MakeUnique<IDBRequestQueueItem>(this, value_or_old_version));
+}
+
+void IDBRequest::HandleResponse() {
+  transit_blob_handles_.clear();
+  if (!transaction_ || !transaction_->HasQueuedResults())
+    return EnqueueResponse();
+  transaction_->EnqueueResult(WTF::MakeUnique<IDBRequestQueueItem>(this));
+}
+
+void IDBRequest::HandleResponse(std::unique_ptr<WebIDBCursor> backend,
+                                IDBKey* key,
+                                IDBKey* primary_key,
+                                RefPtr<IDBValue>&& value) {
+  bool is_wrapped = IDBValueUnwrapper::IsWrapped(value.Get());
+  DCHECK(transaction_);
+  if (!transaction_->HasQueuedResults() && !is_wrapped) {
+    return EnqueueResponse(std::move(backend), key, primary_key,
+                           std::move(value));
+  }
+  transaction_->EnqueueResult(WTF::MakeUnique<IDBRequestQueueItem>(
+      this, std::move(backend), key, primary_key, std::move(value),
+      is_wrapped));
+}
+
+void IDBRequest::HandleResponse(RefPtr<IDBValue>&& value) {
+  bool is_wrapped = IDBValueUnwrapper::IsWrapped(value.Get());
+  DCHECK(transaction_);
+  if (!transaction_->HasQueuedResults() && !is_wrapped)
+    return EnqueueResponse(std::move(value));
+  transaction_->EnqueueResult(
+      WTF::MakeUnique<IDBRequestQueueItem>(this, std::move(value), is_wrapped));
+}
+
+void IDBRequest::HandleResponse(const Vector<RefPtr<IDBValue>>& values) {
+  bool is_wrapped = IDBValueUnwrapper::IsWrapped(values);
+  DCHECK(transaction_);
+  if (!transaction_->HasQueuedResults() && !is_wrapped)
+    return EnqueueResponse(values);
+  transaction_->EnqueueResult(
+      WTF::MakeUnique<IDBRequestQueueItem>(this, values, is_wrapped));
+}
+
+void IDBRequest::HandleResponse(IDBKey* key,
+                                IDBKey* primary_key,
+                                RefPtr<IDBValue>&& value) {
+  bool is_wrapped = IDBValueUnwrapper::IsWrapped(value.Get());
+
+  DCHECK(transaction_);
+  if (!transaction_->HasQueuedResults() && !is_wrapped)
+    return EnqueueResponse(key, primary_key, std::move(value));
+
+  transaction_->EnqueueResult(WTF::MakeUnique<IDBRequestQueueItem>(
+      this, key, primary_key, std::move(value), is_wrapped));
+}
+
 void IDBRequest::EnqueueResponse(DOMException* error) {
-  IDB_TRACE("IDBRequest::onError()");
-  ClearPutOperationBlobs();
+  IDB_TRACE("IDBRequest::EnqueueResponse(DOMException)");
   if (!ShouldEnqueueEvent())
     return;
 
@@ -260,8 +341,8 @@ void IDBRequest::EnqueueResponse(const Vector<String>& string_list) {
 void IDBRequest::EnqueueResponse(std::unique_ptr<WebIDBCursor> backend,
                                  IDBKey* key,
                                  IDBKey* primary_key,
-                                 PassRefPtr<IDBValue> value) {
-  IDB_TRACE("IDBRequest::onSuccess(IDBCursor)");
+                                 RefPtr<IDBValue>&& value) {
+  IDB_TRACE("IDBRequest::EnqueueResponse(IDBCursor)");
   if (!ShouldEnqueueEvent())
     return;
 
@@ -284,8 +365,7 @@ void IDBRequest::EnqueueResponse(std::unique_ptr<WebIDBCursor> backend,
 }
 
 void IDBRequest::EnqueueResponse(IDBKey* idb_key) {
-  IDB_TRACE("IDBRequest::onSuccess(IDBKey)");
-  ClearPutOperationBlobs();
+  IDB_TRACE("IDBRequest::EnqueueResponse(IDBKey)");
   if (!ShouldEnqueueEvent())
     return;
 
@@ -296,7 +376,7 @@ void IDBRequest::EnqueueResponse(IDBKey* idb_key) {
 }
 
 void IDBRequest::EnqueueResponse(const Vector<RefPtr<IDBValue>>& values) {
-  IDB_TRACE("IDBRequest::onSuccess([IDBValue])");
+  IDB_TRACE("IDBRequest::EnqueueResponse([IDBValue])");
   if (!ShouldEnqueueEvent())
     return;
 
@@ -316,12 +396,11 @@ static IDBObjectStore* EffectiveObjectStore(IDBAny* source) {
 }
 #endif  // DCHECK_IS_ON()
 
-void IDBRequest::EnqueueResponse(PassRefPtr<IDBValue> prp_value) {
-  IDB_TRACE("IDBRequest::onSuccess(IDBValue)");
+void IDBRequest::EnqueueResponse(RefPtr<IDBValue>&& value) {
+  IDB_TRACE("IDBRequest::EnqueueResponse(IDBValue)");
   if (!ShouldEnqueueEvent())
     return;
 
-  RefPtr<IDBValue> value(std::move(prp_value));
   AckReceivedBlobs(value.Get());
 
   if (pending_cursor_) {
@@ -337,18 +416,18 @@ void IDBRequest::EnqueueResponse(PassRefPtr<IDBValue> prp_value) {
          value->KeyPath() == EffectiveObjectStore(source_)->IdbKeyPath());
 #endif
 
-  EnqueueResultInternal(IDBAny::Create(value.Release()));
+  EnqueueResultInternal(IDBAny::Create(std::move(value)));
 }
 
 void IDBRequest::EnqueueResponse(int64_t value) {
-  IDB_TRACE("IDBRequest::onSuccess(int64_t)");
+  IDB_TRACE("IDBRequest::EnqueueResponse(int64_t)");
   if (!ShouldEnqueueEvent())
     return;
   EnqueueResultInternal(IDBAny::Create(value));
 }
 
 void IDBRequest::EnqueueResponse() {
-  IDB_TRACE("IDBRequest::onSuccess()");
+  IDB_TRACE("IDBRequest::EnqueueResponse()");
   if (!ShouldEnqueueEvent())
     return;
   EnqueueResultInternal(IDBAny::CreateUndefined());
@@ -369,8 +448,8 @@ void IDBRequest::SetResult(IDBAny* result) {
 
 void IDBRequest::EnqueueResponse(IDBKey* key,
                                  IDBKey* primary_key,
-                                 PassRefPtr<IDBValue> value) {
-  IDB_TRACE("IDBRequest::onSuccess(key, primaryKey, value)");
+                                 RefPtr<IDBValue>&& value) {
+  IDB_TRACE("IDBRequest::EnqueueResponse(IDBKey, IDBKey primaryKey, IDBValue)");
   if (!ShouldEnqueueEvent())
     return;