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 67 matching lines @@
 
 DEFINE_TRACE(IDBRequest) {
   visitor->Trace(transaction_);
   visitor->Trace(source_);
   visitor->Trace(result_);
   visitor->Trace(error_);
   visitor->Trace(enqueued_events_);
   visitor->Trace(pending_cursor_);
   visitor->Trace(cursor_key_);
   visitor->Trace(cursor_primary_key_);
+  visitor->Trace(loader_);
   EventTargetWithInlineData::Trace(visitor);
   SuspendableObject::Trace(visitor);
 }
 
 ScriptValue IDBRequest::result(ScriptState* script_state,
                                ExceptionState& exception_state) {
   if (ready_state_ != DONE) {
     // Must throw if returning an empty value. Message is arbitrary since it
     // will never be seen.
     exception_state.ThrowDOMException(
@@ skipping 160 matching lines @@
   DOMStringList* dom_string_list = DOMStringList::Create();
   for (size_t i = 0; i < string_list.size(); ++i)
     dom_string_list->Append(string_list[i]);
   OnSuccessInternal(IDBAny::Create(dom_string_list));
 }
 
 void IDBRequest::OnSuccess(std::unique_ptr<WebIDBCursor> backend,
                            IDBKey* key,
                            IDBKey* primary_key,
                            PassRefPtr<IDBValue> value) {
+  if (!loader_ && IDBRequestLoader::NeedsUnwrapping(value.Get())) {
+    // TODO(pwnall): Tracing.
+    loader_ = new IDBRequestLoader(this);
+    loader_->Start(std::move(backend), key, primary_key, std::move(value));
+    return;
+  }
+
   IDB_TRACE("IDBRequest::onSuccess(IDBCursor)");
   if (!ShouldEnqueueEvent())
     return;
 
   DCHECK(!pending_cursor_);
   IDBCursor* cursor = nullptr;
   switch (cursor_type_) {
     case IndexedDB::kCursorKeyOnly:
       cursor = IDBCursor::Create(std::move(backend), cursor_direction_, this,
                                  source_.Get(), transaction_.Get());
@@ skipping 14 matching lines @@
   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) {
+  if (!loader_ && IDBRequestLoader::NeedUnwrapping(values)) {
+    // TODO(pwnall): Tracing.
+    loader_ = new IDBRequestLoader(this);
+    loader_->Start(values);
+    return;
+  }
+
   IDB_TRACE("IDBRequest::onSuccess([IDBValue])");
   if (!ShouldEnqueueEvent())
     return;
 
   AckReceivedBlobs(values);
   OnSuccessInternal(IDBAny::Create(values));
 }
 
 #if DCHECK_IS_ON()
 static IDBObjectStore* EffectiveObjectStore(IDBAny* source) {
   if (source->GetType() == IDBAny::kIDBObjectStoreType)
     return source->IdbObjectStore();
   if (source->GetType() == IDBAny::kIDBIndexType)
     return source->IdbIndex()->objectStore();
 
   NOTREACHED();
   return nullptr;
 }
 #endif  // DCHECK_IS_ON()
 
 void IDBRequest::OnSuccess(PassRefPtr<IDBValue> prp_value) {
+  RefPtr<IDBValue> value(std::move(prp_value));
+  if (!loader_ && IDBRequestLoader::NeedsUnwrapping(value.Get())) {
+    // TODO(pwnall): Tracing.
+    loader_ = new IDBRequestLoader(this);
+    loader_->Start(value.Release());
+    return;
+  }
+
   IDB_TRACE("IDBRequest::onSuccess(IDBValue)");
   if (!ShouldEnqueueEvent())
     return;
 
-  RefPtr<IDBValue> value(std::move(prp_value));
   AckReceivedBlobs(value.Get());
 
   if (pending_cursor_) {
     // Value should be null, signifying the end of the cursor's range.
     DCHECK(value->IsNull());
     DCHECK(!value->BlobInfo()->size());
     pending_cursor_->Close();
     pending_cursor_.Clear();
   }
 
@@ skipping 27 matching lines @@
 }
 
 void IDBRequest::SetResult(IDBAny* result) {
   result_ = result;
   result_dirty_ = true;
 }
 
 void IDBRequest::OnSuccess(IDBKey* key,
                            IDBKey* primary_key,
                            PassRefPtr<IDBValue> value) {
+  if (!loader_ && IDBRequestLoader::NeedsUnwrapping(value.Get())) {
+    // TODO(pwnall): Tracing.
+    loader_ = new IDBRequestLoader(this);
+    loader_->Start(key, primary_key, std::move(value));
+    return;
+  }
+
   IDB_TRACE("IDBRequest::onSuccess(key, primaryKey, value)");
   if (!ShouldEnqueueEvent())
     return;
 
   DCHECK(pending_cursor_);
   SetResultCursor(pending_cursor_.Release(), key, primary_key,
                   std::move(value));
 }
 
 bool IDBRequest::HasPendingActivity() const {
@@ skipping 168 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