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/IDBValueWrapper.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;
-  options.write_wasm_to_stream =
+  bool write_wasm_to_stream =
       ExecutionContext::From(script_state)->IsSecureContext();
-  options.for_storage = true;
-  RefPtr<SerializedScriptValue> serialized_value =
-      SerializedScriptValue::Serialize(isolate, value.V8Value(), options,
-                                       exception_state);
+  IDBValueWrapper value_wrapper(isolate, value.V8Value(), write_wasm_to_stream,

[jsbell, 2017/05/08 22:08:01]

Is the motivation for introducing the wrapper here -- instead of just before the
Backend()->Put() call -- for the future when more detailed serialization options
are introduced, e.g. how to treat array buffers, etc?

(For this patch on its own it seems weird to wrap at this point and add
IDBValueWrapper::Clone)

[pwnall, 2017/05/11 23:54:25]

Yes. I wanted to pull out all the serialization concerns so this large method
doesn't have to change when we do new fancy things with WASM modules and perhaps
typed arrays.

+                                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());
+  request->ExtractOutgoingBlobHandlesFrom(&value_wrapper);
+  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