Wrap large IndexedDB values into Blobs before writing to LevelDB.

third_party/WebKit/Source/modules/indexeddb/IDBTransaction.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 18 matching lines @@
 #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/IDBDatabase.h"
 #include "modules/indexeddb/IDBEventDispatcher.h"
 #include "modules/indexeddb/IDBIndex.h"
 #include "modules/indexeddb/IDBObjectStore.h"
 #include "modules/indexeddb/IDBOpenDBRequest.h"
+#include "modules/indexeddb/IDBRequestQueueItem.h"
 #include "modules/indexeddb/IDBTracing.h"
 #include "platform/bindings/ScriptState.h"
 #include "platform/bindings/V8PerIsolateData.h"
 #include "platform/wtf/PtrUtil.h"
 
 #include <memory>
 
 using blink::WebIDBDatabase;
 
 namespace blink {
@@ skipping 324 matching lines @@
 
 void IDBTransaction::RegisterRequest(IDBRequest* request) {
   DCHECK(request);
   DCHECK(!request_list_.Contains(request));
   DCHECK_EQ(state_, kActive);
   request_list_.insert(request);
 }
 
 void IDBTransaction::UnregisterRequest(IDBRequest* request) {
   DCHECK(request);
+
+  // TODO(pwnall): Finish figuring out the abort path.
+  // DCHECK_EQ(request->QueueItem(), nullptr);
+  IDBRequestQueueItem* queue_item = request->QueueItem();
+  if (queue_item) {
+    queue_item->CancelLoading();
+  }
+
   // If we aborted the request, it will already have been removed.
   request_list_.erase(request);
 }
 
+void IDBTransaction::EnqueueResult(
+    std::unique_ptr<IDBRequestQueueItem> result) {
+  DCHECK(result);
+  DCHECK(HasQueuedResults() || !result->IsReady());
+
+  result_queue_.push_back(std::move(result));
+  // StartLoading() may complete post-processing synchronously, so the result
+  // needs to be in the queue before StartLoading() is called.
+  result_queue_.back()->StartLoading();
+}
+
+void IDBTransaction::OnResultReady() {

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

Can you rename this to SendPendingReadyResponses()? Or something else that
described this a little more directly?

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

Let's figure out a good name in the next pass.

+  while (!result_queue_.empty()) {
+    IDBRequestQueueItem* result = result_queue_.front().get();
+    if (!result->IsReady())
+      break;
+
+    result->EnqueueResponse();

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

If you change to callbacks.... you can make this just grab the callback and run
it (so less logic methods on that item). Or, make it something like
TakeEnqueueResponseCallback(), where the transaction owns it and that guarentees
it can't be called twice (trying to replicate your constraints with the
dchecks).

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

Per in person discussion, I've introduced a WTF::Closure to decouple
IDBRequestQueueItem from IDBTransaction.

+    result_queue_.pop_front();
+  }
+}
+
 void IDBTransaction::OnAbort(DOMException* error) {
   IDB_TRACE("IDBTransaction::onAbort");
   if (!GetExecutionContext()) {
     Finished();
     return;
   }
 
   DCHECK_NE(state_, kFinished);
   if (state_ != kFinishing) {
     // Abort was not triggered by front-end.
@@ skipping 218 matching lines @@
     IDBObjectStore* object_store = it.key;
     object_store->ClearIndexCache();
   }
   old_store_metadata_.clear();
 
   deleted_indexes_.clear();
   deleted_object_stores_.clear();
 }
 
 }  // namespace blink