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 11 matching lines @@
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #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"
 #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/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;
 
 namespace blink {
 
 IDBRequest* IDBRequest::Create(ScriptState* script_state,
                                IDBAny* source,
                                IDBTransaction* transaction) {
   IDBRequest* request = new IDBRequest(script_state, source, transaction);
@@ skipping 135 matching lines @@
   if (result_->GetType() == IDBAny::kIDBCursorType)
     return result_->IdbCursor();
   if (result_->GetType() == IDBAny::kIDBCursorWithValueType)
     return result_->IdbCursorWithValue();
   return nullptr;
 }
 
 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;
   cursor_value_ = std::move(value);
   AckReceivedBlobs(cursor_value_.Get());
 
   EnqueueResultInternal(IDBAny::Create(cursor));
 }
 
 void IDBRequest::AckReceivedBlobs(const IDBValue* value) {
@@ skipping 13 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::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;
 
   error_ = error;
   SetResult(IDBAny::CreateUndefined());
   pending_cursor_.Clear();
   EnqueueEvent(Event::CreateCancelableBubble(EventTypeNames::error));
 }
 
 void IDBRequest::EnqueueResponse(const Vector<String>& string_list) {
   IDB_TRACE("IDBRequest::onSuccess(StringList)");
   if (!ShouldEnqueueEvent())
     return;
 
   DOMStringList* dom_string_list = DOMStringList::Create();
   for (size_t i = 0; i < string_list.size(); ++i)
     dom_string_list->Append(string_list[i]);
   EnqueueResultInternal(IDBAny::Create(dom_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;
 
   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());
       break;
     case IndexedDB::kCursorKeyAndValue:
       cursor =
           IDBCursorWithValue::Create(std::move(backend), cursor_direction_,
                                      this, source_.Get(), transaction_.Get());
       break;
     default:
       NOTREACHED();
   }
   SetResultCursor(cursor, key, primary_key, std::move(value));
 }
 
 void IDBRequest::EnqueueResponse(IDBKey* idb_key) {
-  IDB_TRACE("IDBRequest::onSuccess(IDBKey)");
-  ClearPutOperationBlobs();
+  IDB_TRACE("IDBRequest::EnqueueResponse(IDBKey)");
   if (!ShouldEnqueueEvent())
     return;
 
   if (idb_key && idb_key->IsValid())
     EnqueueResultInternal(IDBAny::Create(idb_key));
   else
     EnqueueResultInternal(IDBAny::CreateUndefined());
 }
 
 void IDBRequest::EnqueueResponse(const Vector<RefPtr<IDBValue>>& values) {
-  IDB_TRACE("IDBRequest::onSuccess([IDBValue])");
+  IDB_TRACE("IDBRequest::EnqueueResponse([IDBValue])");
   if (!ShouldEnqueueEvent())
     return;
 
   AckReceivedBlobs(values);
   EnqueueResultInternal(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::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_) {
     // 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();
   }
 
 #if DCHECK_IS_ON()
   DCHECK(!value->PrimaryKey() ||
          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());
 }
 
 void IDBRequest::EnqueueResultInternal(IDBAny* result) {
   DCHECK(GetExecutionContext());
   DCHECK(!pending_cursor_);
   DCHECK(transit_blob_handles_.IsEmpty());
   SetResult(result);
   EnqueueEvent(Event::Create(EventTypeNames::success));
 }
 
 void IDBRequest::SetResult(IDBAny* result) {
   result_ = result;
   result_dirty_ = true;
 }
 
 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;
 
   DCHECK(pending_cursor_);
   SetResultCursor(pending_cursor_.Release(), key, primary_key,
                   std::move(value));
 }
 
 bool IDBRequest::HasPendingActivity() const {
   // FIXME: In an ideal world, we should return true as long as anyone has a or
@@ skipping 169 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