Wrap large IndexedDB values into Blobs before writing to LevelDB.

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

 /*
  * Copyright (C) 2013 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.
  *
@@ skipping 63 matching lines @@
 #endif  // DCHECK_IS_ON()
     request_->WebCallbacksDestroyed();
   }
 }
 
 void WebIDBCallbacksImpl::OnError(const WebIDBDatabaseError& error) {
   if (!request_)
     return;
 
   probe::AsyncTask async_task(request_->GetExecutionContext(), this, "error");
-  request_->EnqueueResponse(
-      DOMException::Create(error.Code(), error.Message()));
+  request_->HandleResponse(DOMException::Create(error.Code(), error.Message()));
 }
 
 void WebIDBCallbacksImpl::OnSuccess(
     const WebVector<WebString>& web_string_list) {
   if (!request_)
     return;
 
   Vector<String> string_list;
   for (size_t i = 0; i < web_string_list.size(); ++i)
     string_list.push_back(web_string_list[i]);
   probe::AsyncTask async_task(request_->GetExecutionContext(), this, "success");
+#if DCHECK_IS_ON()
+  DCHECK(!request_->TransactionHasQueuedResults());
+#endif  // DCHECK_IS_ON()
   request_->EnqueueResponse(string_list);
 }
 
 void WebIDBCallbacksImpl::OnSuccess(WebIDBCursor* cursor,
                                     const WebIDBKey& key,
                                     const WebIDBKey& primary_key,
                                     const WebIDBValue& value) {
   if (!request_)
     return;
 
   probe::AsyncTask async_task(request_->GetExecutionContext(), this, "success");
-  request_->EnqueueResponse(WTF::WrapUnique(cursor), key, primary_key,
-                            IDBValue::Create(value, request_->GetIsolate()));
+  request_->HandleResponse(WTF::WrapUnique(cursor), key, primary_key,
+                           IDBValue::Create(value, request_->GetIsolate()));
 }
 
 void WebIDBCallbacksImpl::OnSuccess(WebIDBDatabase* backend,
                                     const WebIDBMetadata& metadata) {
   std::unique_ptr<WebIDBDatabase> db = WTF::WrapUnique(backend);
   if (request_) {
     probe::AsyncTask async_task(request_->GetExecutionContext(), this,
                                 "success");
+#if DCHECK_IS_ON()
+    DCHECK(!request_->TransactionHasQueuedResults());
+#endif  // DCHECK_IS_ON()
     request_->EnqueueResponse(std::move(db), IDBDatabaseMetadata(metadata));
   } else if (db) {
     db->Close();
   }
 }
 
 void WebIDBCallbacksImpl::OnSuccess(const WebIDBKey& key) {
   if (!request_)
     return;
 
   probe::AsyncTask async_task(request_->GetExecutionContext(), this, "success");
-  request_->EnqueueResponse(key);
+  request_->HandleResponse(key);
 }
 
 void WebIDBCallbacksImpl::OnSuccess(const WebIDBValue& value) {
   if (!request_)
     return;
 
   probe::AsyncTask async_task(request_->GetExecutionContext(), this, "success");
-  request_->EnqueueResponse(IDBValue::Create(value, request_->GetIsolate()));
+  request_->HandleResponse(IDBValue::Create(value, request_->GetIsolate()));
 }
 
 void WebIDBCallbacksImpl::OnSuccess(const WebVector<WebIDBValue>& values) {
   if (!request_)
     return;
 
   probe::AsyncTask async_task(request_->GetExecutionContext(), this, "success");
   Vector<RefPtr<IDBValue>> idb_values(values.size());
   for (size_t i = 0; i < values.size(); ++i)
     idb_values[i] = IDBValue::Create(values[i], request_->GetIsolate());
-  request_->EnqueueResponse(idb_values);
+  request_->HandleResponse(idb_values);
 }
 
 void WebIDBCallbacksImpl::OnSuccess(long long value) {
   if (!request_)
     return;
 
   probe::AsyncTask async_task(request_->GetExecutionContext(), this, "success");
-  request_->EnqueueResponse(value);
+  request_->HandleResponse(value);
 }
 
 void WebIDBCallbacksImpl::OnSuccess() {
   if (!request_)
     return;
 
   probe::AsyncTask async_task(request_->GetExecutionContext(), this, "success");
-  request_->EnqueueResponse();
+  request_->HandleResponse();
 }
 
 void WebIDBCallbacksImpl::OnSuccess(const WebIDBKey& key,
                                     const WebIDBKey& primary_key,
                                     const WebIDBValue& value) {
   if (!request_)
     return;
 
   probe::AsyncTask async_task(request_->GetExecutionContext(), this, "success");
-  request_->EnqueueResponse(key, primary_key,
-                            IDBValue::Create(value, request_->GetIsolate()));
+  request_->HandleResponse(key, primary_key,
+                           IDBValue::Create(value, request_->GetIsolate()));
 }
 
 void WebIDBCallbacksImpl::OnBlocked(long long old_version) {
   if (!request_)
     return;
 
   probe::AsyncTask async_task(request_->GetExecutionContext(), this, "blocked");
+#if DCHECK_IS_ON()
+  DCHECK(!request_->TransactionHasQueuedResults());
+#endif  // DCHECK_IS_ON()
   request_->EnqueueBlocked(old_version);
 }
 
 void WebIDBCallbacksImpl::OnUpgradeNeeded(long long old_version,
                                           WebIDBDatabase* database,
                                           const WebIDBMetadata& metadata,
                                           unsigned short data_loss,
                                           WebString data_loss_message) {
   std::unique_ptr<WebIDBDatabase> db = WTF::WrapUnique(database);
   if (request_) {
     probe::AsyncTask async_task(request_->GetExecutionContext(), this,
                                 "upgradeNeeded");
+#if DCHECK_IS_ON()
+    DCHECK(!request_->TransactionHasQueuedResults());
+#endif  // DCHECK_IS_ON()
     request_->EnqueueUpgradeNeeded(
         old_version, std::move(db), IDBDatabaseMetadata(metadata),
         static_cast<WebIDBDataLoss>(data_loss), data_loss_message);
   } else {
     db->Close();
   }
 }
 
 void WebIDBCallbacksImpl::Detach() {
   request_.Clear();
 }
 
 }  // namespace blink