Wrap large IndexedDB values into Blobs before writing to LevelDB.

third_party/WebKit/Source/modules/indexeddb/IDBObjectStore.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 22 matching lines @@
 #include "bindings/modules/v8/ToV8ForModules.h"
 #include "bindings/modules/v8/V8BindingForModules.h"
 #include "core/dom/DOMStringList.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContext.h"
 #include "modules/indexeddb/IDBAny.h"
 #include "modules/indexeddb/IDBCursorWithValue.h"
 #include "modules/indexeddb/IDBDatabase.h"
 #include "modules/indexeddb/IDBKeyPath.h"
 #include "modules/indexeddb/IDBTracing.h"
+#include "modules/indexeddb/IDBValueWrapping.h"
 #include "platform/Histogram.h"
 #include "platform/SharedBuffer.h"
 #include "platform/bindings/ScriptState.h"
+#include "platform/wtf/RefPtr.h"
 #include "public/platform/WebBlobInfo.h"
 #include "public/platform/WebData.h"
 #include "public/platform/WebVector.h"
 #include "public/platform/modules/indexeddb/WebIDBKey.h"
 #include "public/platform/modules/indexeddb/WebIDBKeyRange.h"
 #include "v8/include/v8.h"
 
 using blink::WebBlobInfo;
 using blink::WebIDBCallbacks;
 using blink::WebIDBCursor;
@@ skipping 313 matching lines @@
     return nullptr;
   }
   if (transaction_->IsReadOnly()) {
     exception_state.ThrowDOMException(
         kReadOnlyError, IDBDatabase::kTransactionReadOnlyErrorMessage);
     return nullptr;
   }
 
   v8::Isolate* isolate = script_state->GetIsolate();
   DCHECK(isolate->InContext());
-  Vector<WebBlobInfo> blob_info;
-  SerializedScriptValue::SerializeOptions options;
-  options.blob_info = &blob_info;
-
   // TODO(crbug.com/719053): This wasm behavior differs from other browsers.
-  options.write_wasm_to_stream =
+  bool write_wasm_to_stream =
       ExecutionContext::From(script_state)->IsSecureContext();
-  options.for_storage = SerializedScriptValue::kForStorage;
-  RefPtr<SerializedScriptValue> serialized_value =
-      SerializedScriptValue::Serialize(isolate, value.V8Value(), options,
-                                       exception_state);
+  IDBValueWrapper value_wrapper(isolate, value.V8Value(), write_wasm_to_stream,
+                                exception_state);
   if (exception_state.HadException())
     return nullptr;
 
   // Keys that need to be extracted must be taken from a clone so that
   // side effects (i.e. getters) are not triggered. Construct the
   // clone lazily since the operation may be expensive.
   ScriptValue clone;
 
   const IDBKeyPath& key_path = IdbKeyPath();
   const bool uses_in_line_keys = !key_path.IsNull();
   const bool has_key_generator = autoIncrement();
 
   if (put_mode != kWebIDBPutModeCursorUpdate && uses_in_line_keys && key) {
     exception_state.ThrowDOMException(kDataError,
                                       "The object store uses in-line keys and "
                                       "the key parameter was provided.");
     return nullptr;
   }
 
   // This test logically belongs in IDBCursor, but must operate on the cloned
   // value.
   if (put_mode == kWebIDBPutModeCursorUpdate && uses_in_line_keys) {
     DCHECK(key);
-    if (clone.IsEmpty())
-      clone = DeserializeScriptValue(script_state, serialized_value.Get(),
-                                     &blob_info);
+    DCHECK(clone.IsEmpty());
+    value_wrapper.Clone(script_state, &clone);
     IDBKey* key_path_key = ScriptValue::To<IDBKey*>(
         script_state->GetIsolate(), clone, exception_state, key_path);
     if (exception_state.HadException())
       return nullptr;
     if (!key_path_key || !key_path_key->IsEqual(key)) {
       exception_state.ThrowDOMException(
           kDataError,
           "The effective object store of this cursor uses in-line keys and "
           "evaluating the key path of the value parameter results in a "
           "different value than the cursor's effective key.");
       return nullptr;
     }
   }
 
   if (!uses_in_line_keys && !has_key_generator && !key) {
     exception_state.ThrowDOMException(kDataError,
                                       "The object store uses out-of-line keys "
                                       "and has no key generator and the key "
                                       "parameter was not provided.");
     return nullptr;
   }
   if (uses_in_line_keys) {
-    if (clone.IsEmpty()) {
-      clone = DeserializeScriptValue(script_state, serialized_value.Get(),
-                                     &blob_info);
-    }
+    if (clone.IsEmpty())
+      value_wrapper.Clone(script_state, &clone);
     IDBKey* key_path_key = ScriptValue::To<IDBKey*>(
         script_state->GetIsolate(), clone, exception_state, key_path);
     if (exception_state.HadException())
       return nullptr;
     if (key_path_key && !key_path_key->IsValid()) {
       exception_state.ThrowDOMException(
           kDataError,
           "Evaluating the object store's key path "
           "yielded a value that is not a valid "
           "key.");
@@ skipping 33 matching lines @@
     DEFINE_THREAD_SAFE_STATIC_LOCAL(
         EnumerationHistogram, key_type_histogram,
         new EnumerationHistogram("WebCore.IndexedDB.ObjectStore.Record.KeyType",
                                  static_cast<int>(IDBKey::kTypeEnumMax)));
     key_type_histogram.Count(static_cast<int>(key->GetType()));
   }
 
   Vector<int64_t> index_ids;
   HeapVector<IndexKeys> index_keys;
   for (const auto& it : Metadata().indexes) {
-    if (clone.IsEmpty()) {
-      clone = DeserializeScriptValue(script_state, serialized_value.Get(),
-                                     &blob_info);
-    }
+    if (clone.IsEmpty())
+      value_wrapper.Clone(script_state, &clone);
     IndexKeys keys;
     GenerateIndexKeysForValue(script_state->GetIsolate(), *it.value, clone,
                               &keys);
     index_ids.push_back(it.key);
     index_keys.push_back(keys);
   }
 
   IDBRequest* request =
       IDBRequest::Create(script_state, source, transaction_.Get());
-  Vector<char> wire_bytes;
-  serialized_value->ToWireBytes(wire_bytes);
-  RefPtr<SharedBuffer> value_buffer = SharedBuffer::AdoptVector(wire_bytes);
 
-  request->StorePutOperationBlobs(serialized_value->BlobDataHandles());
+  value_wrapper.ExtractBlobDataHandles(request->transit_blob_handles());
+  value_wrapper.WrapIfBiggerThan(IDBValueWrapper::kWrapThreshold);
 
-  BackendDB()->Put(transaction_->Id(), Id(), WebData(value_buffer), blob_info,
-                   key, static_cast<WebIDBPutMode>(put_mode),
-                   request->CreateWebCallbacks().release(), index_ids,
-                   index_keys);
+  BackendDB()->Put(
+      transaction_->Id(), Id(), WebData(value_wrapper.ExtractWireBytes()),
+      value_wrapper.WrappedBlobInfo(), key,
+      static_cast<WebIDBPutMode>(put_mode),
+      request->CreateWebCallbacks().release(), index_ids, index_keys);
+
   return request;
 }
 
 IDBRequest* IDBObjectStore::deleteFunction(ScriptState* script_state,
                                            const ScriptValue& key,
                                            ExceptionState& exception_state) {
   IDB_TRACE("IDBObjectStore::delete");
   if (IsDeleted()) {
     exception_state.ThrowDOMException(
         kInvalidStateError, IDBDatabase::kObjectStoreDeletedErrorMessage);
@@ skipping 529 matching lines @@
     }
   }
   return IDBIndexMetadata::kInvalidId;
 }
 
 WebIDBDatabase* IDBObjectStore::BackendDB() const {
   return transaction_->BackendDB();
 }
 
 }  // namespace blink