Wrap large IndexedDB values into Blobs before writing to LevelDB.

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

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 23 matching lines @@
 #include "bindings/modules/v8/ToV8ForModules.h"
 #include "bindings/modules/v8/V8BindingForModules.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/events/EventQueue.h"
 #include "modules/IndexedDBNames.h"
 #include "modules/indexeddb/IDBCursorWithValue.h"
 #include "modules/indexeddb/IDBDatabase.h"
 #include "modules/indexeddb/IDBEventDispatcher.h"
+#include "modules/indexeddb/IDBRequestLoader.h"
 #include "modules/indexeddb/IDBTracing.h"
 #include "modules/indexeddb/IDBValue.h"
 #include "modules/indexeddb/WebIDBCallbacksImpl.h"
 #include "platform/SharedBuffer.h"
 #include "public/platform/WebBlobInfo.h"
 
 using blink::WebIDBCursor;
 
 namespace blink {
 
@@ skipping 178 matching lines @@
   if (!GetExecutionContext())
     return false;
   DCHECK(ready_state_ == PENDING || ready_state_ == DONE);
   if (request_aborted_)
     return false;
   DCHECK_EQ(ready_state_, PENDING);
   DCHECK(!error_ && !result_);
   return true;
 }
 
+void IDBRequest::QueueResult(DOMException* error) {
+  outgoing_blob_handles_.clear();
+
+  if (!transaction_ || !transaction_->HasQueuedResult())
+    return OnError(error);
+
+  transaction_->EnqueueResult(new IDBRequestQueueItem(this, error));
+}
+
+void IDBRequest::QueueResult(IDBKey* key) {
+  outgoing_blob_handles_.clear();
+
+  DCHECK(transaction_);
+  if (!transaction_->HasQueuedResult())
+    return OnSuccess(key);
+
+  transaction_->EnqueueResult(new IDBRequestQueueItem(this, key));
+}
+
+void IDBRequest::QueueResult(std::unique_ptr<WebIDBCursor> backend,
+                             IDBKey* key,
+                             IDBKey* primary_key,
+                             PassRefPtr<IDBValue> value) {
+  bool needs_unwrapping = IDBRequestLoader::NeedsUnwrapping(value.Get());
+
+  DCHECK(transaction_);
+  if (!transaction_->HasQueuedResult() && !needs_unwrapping)
+    return OnSuccess(std::move(backend), key, primary_key, std::move(value));
+
+  IDBRequestQueueItem* queue_item = new IDBRequestQueueItem(
+      this, std::move(backend), key, primary_key, std::move(value));
+  if (needs_unwrapping)
+    queue_item->AttachLoader();
+  transaction_->EnqueueResult(queue_item);
+  queue_item->StartLoading();
+}
+void IDBRequest::QueueResult(PassRefPtr<IDBValue> value) {
+  bool needs_unwrapping = IDBRequestLoader::NeedsUnwrapping(value.Get());
+
+  DCHECK(transaction_);
+  if (!transaction_->HasQueuedResult() && !needs_unwrapping)
+    return OnSuccess(std::move(value));
+
+  IDBRequestQueueItem* queue_item =
+      new IDBRequestQueueItem(this, std::move(value));
+  if (needs_unwrapping)
+    queue_item->AttachLoader();
+  transaction_->EnqueueResult(queue_item);
+  queue_item->StartLoading();
+}
+
+void IDBRequest::QueueResult(const Vector<RefPtr<IDBValue>>& values) {
+  bool needs_unwrapping = IDBRequestLoader::NeedUnwrapping(values);
+
+  DCHECK(transaction_);
+  if (!transaction_->HasQueuedResult() && !needs_unwrapping)
+    return OnSuccess(values);
+
+  IDBRequestQueueItem* queue_item = new IDBRequestQueueItem(this, values);
+  if (needs_unwrapping)
+    queue_item->AttachLoader();
+  transaction_->EnqueueResult(queue_item);
+  queue_item->StartLoading();
+}
+
+void IDBRequest::QueueResult(IDBKey* key,
+                             IDBKey* primary_key,
+                             PassRefPtr<IDBValue> value) {
+  bool needs_unwrapping = IDBRequestLoader::NeedsUnwrapping(value.Get());
+
+  DCHECK(transaction_);
+  if (!transaction_->HasQueuedResult() && !needs_unwrapping)
+    return OnSuccess(key, primary_key, std::move(value));
+
+  IDBRequestQueueItem* queue_item =
+      new IDBRequestQueueItem(this, key, primary_key, std::move(value));
+  if (needs_unwrapping)
+    queue_item->AttachLoader();
+  transaction_->EnqueueResult(queue_item);
+  queue_item->StartLoading();
+}
+
 void IDBRequest::OnError(DOMException* error) {
   IDB_TRACE("IDBRequest::onError()");
-  ClearPutOperationBlobs();

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

Would we put these in the QueueResult callsa as well? We just need error and
onsuccess(key).

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

I called clear() directly on the vector. It seemed to me that a method name
doesn't add semantic information over "outgoing_blob_handles_.clear()"
("transfer_blob_handles_.clear()", if you prefer).

   if (!ShouldEnqueueEvent())
     return;
 
   error_ = error;
   SetResult(IDBAny::CreateUndefined());
   pending_cursor_.Clear();
   EnqueueEvent(Event::CreateCancelableBubble(EventTypeNames::error));
 }
 
 void IDBRequest::OnSuccess(const Vector<String>& string_list) {
@@ skipping 28 matching lines @@
                                      this, source_.Get(), transaction_.Get());
       break;
     default:
       NOTREACHED();
   }
   SetResultCursor(cursor, key, primary_key, std::move(value));
 }
 
 void IDBRequest::OnSuccess(IDBKey* idb_key) {
   IDB_TRACE("IDBRequest::onSuccess(IDBKey)");
-  ClearPutOperationBlobs();
   if (!ShouldEnqueueEvent())
     return;
 
   if (idb_key && idb_key->IsValid())
     OnSuccessInternal(IDBAny::Create(idb_key));
   else
     OnSuccessInternal(IDBAny::CreateUndefined());
 }
 
 void IDBRequest::OnSuccess(const Vector<RefPtr<IDBValue>>& values) {
@@ skipping 51 matching lines @@
 void IDBRequest::OnSuccess() {
   IDB_TRACE("IDBRequest::onSuccess()");
   if (!ShouldEnqueueEvent())
     return;
   OnSuccessInternal(IDBAny::CreateUndefined());
 }
 
 void IDBRequest::OnSuccessInternal(IDBAny* result) {
   DCHECK(GetExecutionContext());
   DCHECK(!pending_cursor_);
-  DCHECK(transit_blob_handles_.IsEmpty());
+  DCHECK(outgoing_blob_handles_.IsEmpty());
   SetResult(result);
   EnqueueEvent(Event::Create(EventTypeNames::success));
 }
 
 void IDBRequest::SetResult(IDBAny* result) {
   result_ = result;
   result_dirty_ = true;
 }
 
 void IDBRequest::OnSuccess(IDBKey* key,
@@ skipping 180 matching lines @@
 }
 
 void IDBRequest::DequeueEvent(Event* event) {
   for (size_t i = 0; i < enqueued_events_.size(); ++i) {
     if (enqueued_events_[i].Get() == event)
       enqueued_events_.erase(i);
   }
 }
 
 }  // namespace blink