1 /*
2 * Copyright (C) 2011 Google Inc. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
15 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
16 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17 * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
18 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
19 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
20 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
21 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 */
25
26 #include "config.h"
27 #include "bindings/v8/IDBBindingUtilities.h"
28
29 #include "bindings/core/v8/V8DOMStringList.h"
30 #include "bindings/modules/v8/V8IDBCursor.h"
31 #include "bindings/modules/v8/V8IDBCursorWithValue.h"
32 #include "bindings/modules/v8/V8IDBDatabase.h"
33 #include "bindings/modules/v8/V8IDBIndex.h"
34 #include "bindings/modules/v8/V8IDBKeyRange.h"
35 #include "bindings/modules/v8/V8IDBObjectStore.h"
36 #include "bindings/modules/v8/V8IDBRequest.h"
37 #include "bindings/modules/v8/V8IDBTransaction.h"
38 #include "bindings/v8/SerializedScriptValue.h"
39 #include "bindings/v8/V8Binding.h"
40 #include "bindings/v8/V8HiddenValue.h"
41 #include "bindings/v8/custom/V8ArrayBufferViewCustom.h"
42 #include "bindings/v8/custom/V8Uint8ArrayCustom.h"
43 #include "modules/indexeddb/IDBKey.h"
44 #include "modules/indexeddb/IDBKeyPath.h"
45 #include "modules/indexeddb/IDBKeyRange.h"
46 #include "modules/indexeddb/IDBTracing.h"
47 #include "platform/RuntimeEnabledFeatures.h"
48 #include "platform/SharedBuffer.h"
49 #include "wtf/ArrayBufferView.h"
50 #include "wtf/MathExtras.h"
51 #include "wtf/Uint8Array.h"
52 #include "wtf/Vector.h"
53
54 namespace WebCore {
55
56 static v8::Handle<v8::Value> deserializeIDBValueBuffer(v8::Isolate*, SharedBuffer*, const Vector<blink::WebBlobInfo>*);
57
toV8(const IDBKeyPath & value,v8::Handle<v8::Object> creationContext,v8::Isolate * isolate)58 static v8::Handle<v8::Value> toV8(const IDBKeyPath& value, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
59 {
60 switch (value.type()) {
61 case IDBKeyPath::NullType:
62 return v8::Null(isolate);
63 case IDBKeyPath::StringType:
64 return v8String(isolate, value.string());
65 case IDBKeyPath::ArrayType:
66 RefPtrWillBeRawPtr<DOMStringList> keyPaths = DOMStringList::create();
67 for (Vector<String>::const_iterator it = value.array().begin(); it != value.array().end(); ++it)
68 keyPaths->append(*it);
69 return toV8(keyPaths.release(), creationContext, isolate);
70 }
71 ASSERT_NOT_REACHED();
72 return v8::Undefined(isolate);
73 }
74
toV8(const IDBKey * key,v8::Handle<v8::Object> creationContext,v8::Isolate * isolate)75 static v8::Handle<v8::Value> toV8(const IDBKey* key, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
76 {
77 if (!key) {
78 // This should be undefined, not null.
79 // Spec: http://dvcs.w3.org/hg/IndexedDB/raw-file/tip/Overview.html#idl-def-IDBKeyRange
80 return v8Undefined();
81 }
82
83 switch (key->type()) {
84 case IDBKey::InvalidType:
85 case IDBKey::MinType:
86 ASSERT_NOT_REACHED();
87 return v8Undefined();
88 case IDBKey::NumberType:
89 return v8::Number::New(isolate, key->number());
90 case IDBKey::StringType:
91 return v8String(isolate, key->string());
92 case IDBKey::BinaryType:
93 return toV8(Uint8Array::create(reinterpret_cast<const unsigned char*>(key->binary()->data()), key->binary()->size()), creationContext, isolate);
94 case IDBKey::DateType:
95 return v8::Date::New(isolate, key->date());
96 case IDBKey::ArrayType:
97 {
98 v8::Local<v8::Array> array = v8::Array::New(isolate, key->array().size());
99 for (size_t i = 0; i < key->array().size(); ++i)
100 array->Set(i, toV8(key->array()[i].get(), creationContext, isolate));
101 return array;
102 }
103 }
104
105 ASSERT_NOT_REACHED();
106 return v8Undefined();
107 }
108
toV8(const IDBAny * impl,v8::Handle<v8::Object> creationContext,v8::Isolate * isolate)109 static v8::Handle<v8::Value> toV8(const IDBAny* impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
110 {
111 if (!impl)
112 return v8::Null(isolate);
113
114 switch (impl->type()) {
115 case IDBAny::UndefinedType:
116 return v8::Undefined(isolate);
117 case IDBAny::NullType:
118 return v8::Null(isolate);
119 case IDBAny::DOMStringListType:
120 return toV8(impl->domStringList(), creationContext, isolate);
121 case IDBAny::IDBCursorType: {
122 // Ensure request wrapper is kept alive at least as long as the cursor wrapper,
123 // so that event listeners are retained.
124 v8::Handle<v8::Value> cursor = toV8(impl->idbCursor(), creationContext, isolate);
125 v8::Handle<v8::Value> request = toV8(impl->idbCursor()->request(), creationContext, isolate);
126 V8HiddenValue::setHiddenValue(isolate, cursor->ToObject(), V8HiddenValue::idbCursorRequest(isolate), request);
127 return cursor;
128 }
129 case IDBAny::IDBCursorWithValueType: {
130 // Ensure request wrapper is kept alive at least as long as the cursor wrapper,
131 // so that event listeners are retained.
132 v8::Handle<v8::Value> cursor = toV8(impl->idbCursorWithValue(), creationContext, isolate);
133 v8::Handle<v8::Value> request = toV8(impl->idbCursorWithValue()->request(), creationContext, isolate);
134 V8HiddenValue::setHiddenValue(isolate, cursor->ToObject(), V8HiddenValue::idbCursorRequest(isolate), request);
135 return cursor;
136 }
137 case IDBAny::IDBDatabaseType:
138 return toV8(impl->idbDatabase(), creationContext, isolate);
139 case IDBAny::IDBIndexType:
140 return toV8(impl->idbIndex(), creationContext, isolate);
141 case IDBAny::IDBObjectStoreType:
142 return toV8(impl->idbObjectStore(), creationContext, isolate);
143 case IDBAny::IDBTransactionType:
144 return toV8(impl->idbTransaction(), creationContext, isolate);
145 case IDBAny::BufferType:
146 return deserializeIDBValueBuffer(isolate, impl->buffer(), impl->blobInfo());
147 case IDBAny::StringType:
148 return v8String(isolate, impl->string());
149 case IDBAny::IntegerType:
150 return v8::Number::New(isolate, impl->integer());
151 case IDBAny::KeyType:
152 return toV8(impl->key(), creationContext, isolate);
153 case IDBAny::KeyPathType:
154 return toV8(impl->keyPath(), creationContext, isolate);
155 case IDBAny::BufferKeyAndKeyPathType: {
156 v8::Handle<v8::Value> value = deserializeIDBValueBuffer(isolate, impl->buffer(), impl->blobInfo());
157 v8::Handle<v8::Value> key = toV8(impl->key(), creationContext, isolate);
158 bool injected = injectV8KeyIntoV8Value(isolate, key, value, impl->keyPath());
159 ASSERT_UNUSED(injected, injected);
160 return value;
161 }
162 }
163
164 ASSERT_NOT_REACHED();
165 return v8::Undefined(isolate);
166 }
167
168 static const size_t maximumDepth = 2000;
169
createIDBKeyFromValue(v8::Isolate * isolate,v8::Handle<v8::Value> value,Vector<v8::Handle<v8::Array>> & stack,bool allowExperimentalTypes=false)170 static IDBKey* createIDBKeyFromValue(v8::Isolate* isolate, v8::Handle<v8::Value> value, Vector<v8::Handle<v8::Array> >& stack, bool allowExperimentalTypes = false)
171 {
172 if (value->IsNumber() && !std::isnan(value->NumberValue()))
173 return IDBKey::createNumber(value->NumberValue());
174 if (value->IsString())
175 return IDBKey::createString(toCoreString(value.As<v8::String>()));
176 if (value->IsDate() && !std::isnan(value->NumberValue()))
177 return IDBKey::createDate(value->NumberValue());
178 if (value->IsUint8Array() && (allowExperimentalTypes || RuntimeEnabledFeatures::indexedDBExperimentalEnabled())) {
179 // Per discussion in https://www.w3.org/Bugs/Public/show_bug.cgi?id=23332 the
180 // input type is constrained to Uint8Array to match the output type.
181 ArrayBufferView* view = WebCore::V8ArrayBufferView::toNative(value->ToObject());
182 const char* start = static_cast<const char*>(view->baseAddress());
183 size_t length = view->byteLength();
184 return IDBKey::createBinary(SharedBuffer::create(start, length));
185 }
186 if (value->IsArray()) {
187 v8::Handle<v8::Array> array = v8::Handle<v8::Array>::Cast(value);
188
189 if (stack.contains(array))
190 return 0;
191 if (stack.size() >= maximumDepth)
192 return 0;
193 stack.append(array);
194
195 IDBKey::KeyArray subkeys;
196 uint32_t length = array->Length();
197 for (uint32_t i = 0; i < length; ++i) {
198 v8::Local<v8::Value> item = array->Get(v8::Int32::New(isolate, i));
199 IDBKey* subkey = createIDBKeyFromValue(isolate, item, stack, allowExperimentalTypes);
200 if (!subkey)
201 subkeys.append(IDBKey::createInvalid());
202 else
203 subkeys.append(subkey);
204 }
205
206 stack.removeLast();
207 return IDBKey::createArray(subkeys);
208 }
209 return 0;
210 }
211
createIDBKeyFromValue(v8::Isolate * isolate,v8::Handle<v8::Value> value,bool allowExperimentalTypes=false)212 static IDBKey* createIDBKeyFromValue(v8::Isolate* isolate, v8::Handle<v8::Value> value, bool allowExperimentalTypes = false)
213 {
214 Vector<v8::Handle<v8::Array> > stack;
215 if (IDBKey* key = createIDBKeyFromValue(isolate, value, stack, allowExperimentalTypes))
216 return key;
217 return IDBKey::createInvalid();
218 }
219
220 template<typename T>
getValueFrom(T indexOrName,v8::Handle<v8::Value> & v8Value)221 static bool getValueFrom(T indexOrName, v8::Handle<v8::Value>& v8Value)
222 {
223 v8::Local<v8::Object> object = v8Value->ToObject();
224 if (!object->Has(indexOrName))
225 return false;
226 v8Value = object->Get(indexOrName);
227 return true;
228 }
229
230 template<typename T>
setValue(v8::Handle<v8::Value> & v8Object,T indexOrName,const v8::Handle<v8::Value> & v8Value)231 static bool setValue(v8::Handle<v8::Value>& v8Object, T indexOrName, const v8::Handle<v8::Value>& v8Value)
232 {
233 v8::Local<v8::Object> object = v8Object->ToObject();
234 return object->Set(indexOrName, v8Value);
235 }
236
get(v8::Isolate * isolate,v8::Handle<v8::Value> & object,const String & keyPathElement,v8::Handle<v8::Value> & result)237 static bool get(v8::Isolate* isolate, v8::Handle<v8::Value>& object, const String& keyPathElement, v8::Handle<v8::Value>& result)
238 {
239 if (object->IsString() && keyPathElement == "length") {
240 int32_t length = v8::Handle<v8::String>::Cast(object)->Length();
241 result = v8::Number::New(isolate, length);
242 return true;
243 }
244 return object->IsObject() && getValueFrom(v8String(isolate, keyPathElement), result);
245 }
246
canSet(v8::Handle<v8::Value> & object,const String & keyPathElement)247 static bool canSet(v8::Handle<v8::Value>& object, const String& keyPathElement)
248 {
249 return object->IsObject();
250 }
251
set(v8::Isolate * isolate,v8::Handle<v8::Value> & object,const String & keyPathElement,const v8::Handle<v8::Value> & v8Value)252 static bool set(v8::Isolate* isolate, v8::Handle<v8::Value>& object, const String& keyPathElement, const v8::Handle<v8::Value>& v8Value)
253 {
254 return canSet(object, keyPathElement) && setValue(object, v8String(isolate, keyPathElement), v8Value);
255 }
256
getNthValueOnKeyPath(v8::Isolate * isolate,v8::Handle<v8::Value> & rootValue,const Vector<String> & keyPathElements,size_t index)257 static v8::Handle<v8::Value> getNthValueOnKeyPath(v8::Isolate* isolate, v8::Handle<v8::Value>& rootValue, const Vector<String>& keyPathElements, size_t index)
258 {
259 v8::Handle<v8::Value> currentValue(rootValue);
260 ASSERT(index <= keyPathElements.size());
261 for (size_t i = 0; i < index; ++i) {
262 v8::Handle<v8::Value> parentValue(currentValue);
263 if (!get(isolate, parentValue, keyPathElements[i], currentValue))
264 return v8Undefined();
265 }
266
267 return currentValue;
268 }
269
canInjectNthValueOnKeyPath(v8::Isolate * isolate,v8::Handle<v8::Value> & rootValue,const Vector<String> & keyPathElements,size_t index)270 static bool canInjectNthValueOnKeyPath(v8::Isolate* isolate, v8::Handle<v8::Value>& rootValue, const Vector<String>& keyPathElements, size_t index)
271 {
272 if (!rootValue->IsObject())
273 return false;
274
275 v8::Handle<v8::Value> currentValue(rootValue);
276
277 ASSERT(index <= keyPathElements.size());
278 for (size_t i = 0; i < index; ++i) {
279 v8::Handle<v8::Value> parentValue(currentValue);
280 const String& keyPathElement = keyPathElements[i];
281 if (!get(isolate, parentValue, keyPathElement, currentValue))
282 return canSet(parentValue, keyPathElement);
283 }
284 return true;
285 }
286
287
ensureNthValueOnKeyPath(v8::Isolate * isolate,v8::Handle<v8::Value> & rootValue,const Vector<String> & keyPathElements,size_t index)288 static v8::Handle<v8::Value> ensureNthValueOnKeyPath(v8::Isolate* isolate, v8::Handle<v8::Value>& rootValue, const Vector<String>& keyPathElements, size_t index)
289 {
290 v8::Handle<v8::Value> currentValue(rootValue);
291
292 ASSERT(index <= keyPathElements.size());
293 for (size_t i = 0; i < index; ++i) {
294 v8::Handle<v8::Value> parentValue(currentValue);
295 const String& keyPathElement = keyPathElements[i];
296 if (!get(isolate, parentValue, keyPathElement, currentValue)) {
297 v8::Handle<v8::Object> object = v8::Object::New(isolate);
298 if (!set(isolate, parentValue, keyPathElement, object))
299 return v8Undefined();
300 currentValue = object;
301 }
302 }
303
304 return currentValue;
305 }
306
createIDBKeyFromScriptValueAndKeyPathInternal(v8::Isolate * isolate,const ScriptValue & value,const String & keyPath,bool allowExperimentalTypes)307 static IDBKey* createIDBKeyFromScriptValueAndKeyPathInternal(v8::Isolate* isolate, const ScriptValue& value, const String& keyPath, bool allowExperimentalTypes)
308 {
309 Vector<String> keyPathElements;
310 IDBKeyPathParseError error;
311 IDBParseKeyPath(keyPath, keyPathElements, error);
312 ASSERT(error == IDBKeyPathParseErrorNone);
313 ASSERT(isolate->InContext());
314
315 v8::HandleScope handleScope(isolate);
316 v8::Handle<v8::Value> v8Value(value.v8Value());
317 v8::Handle<v8::Value> v8Key(getNthValueOnKeyPath(isolate, v8Value, keyPathElements, keyPathElements.size()));
318 if (v8Key.IsEmpty())
319 return 0;
320 return createIDBKeyFromValue(isolate, v8Key, allowExperimentalTypes);
321 }
322
createIDBKeyFromScriptValueAndKeyPathInternal(v8::Isolate * isolate,const ScriptValue & value,const IDBKeyPath & keyPath,bool allowExperimentalTypes=false)323 static IDBKey* createIDBKeyFromScriptValueAndKeyPathInternal(v8::Isolate* isolate, const ScriptValue& value, const IDBKeyPath& keyPath, bool allowExperimentalTypes = false)
324 {
325 ASSERT(!keyPath.isNull());
326 v8::HandleScope handleScope(isolate);
327 if (keyPath.type() == IDBKeyPath::ArrayType) {
328 IDBKey::KeyArray result;
329 const Vector<String>& array = keyPath.array();
330 for (size_t i = 0; i < array.size(); ++i) {
331 IDBKey* key = createIDBKeyFromScriptValueAndKeyPathInternal(isolate, value, array[i], allowExperimentalTypes);
332 if (!key)
333 return 0;
334 result.append(key);
335 }
336 return IDBKey::createArray(result);
337 }
338
339 ASSERT(keyPath.type() == IDBKeyPath::StringType);
340 return createIDBKeyFromScriptValueAndKeyPathInternal(isolate, value, keyPath.string(), allowExperimentalTypes);
341 }
342
createIDBKeyFromScriptValueAndKeyPath(v8::Isolate * isolate,const ScriptValue & value,const IDBKeyPath & keyPath)343 IDBKey* createIDBKeyFromScriptValueAndKeyPath(v8::Isolate* isolate, const ScriptValue& value, const IDBKeyPath& keyPath)
344 {
345 IDB_TRACE("createIDBKeyFromScriptValueAndKeyPath");
346 return createIDBKeyFromScriptValueAndKeyPathInternal(isolate, value, keyPath);
347 }
348
deserializeIDBValueBuffer(v8::Isolate * isolate,SharedBuffer * buffer,const Vector<blink::WebBlobInfo> * blobInfo)349 static v8::Handle<v8::Value> deserializeIDBValueBuffer(v8::Isolate* isolate, SharedBuffer* buffer, const Vector<blink::WebBlobInfo>* blobInfo)
350 {
351 ASSERT(isolate->InContext());
352 if (!buffer)
353 return v8::Null(isolate);
354
355 // FIXME: The extra copy here can be eliminated by allowing SerializedScriptValue to take a raw const char* or const uint8_t*.
356 Vector<uint8_t> value;
357 value.append(buffer->data(), buffer->size());
358 RefPtr<SerializedScriptValue> serializedValue = SerializedScriptValue::createFromWireBytes(value);
359 return serializedValue->deserialize(isolate, 0, blobInfo);
360 }
361
injectV8KeyIntoV8Value(v8::Isolate * isolate,v8::Handle<v8::Value> key,v8::Handle<v8::Value> value,const IDBKeyPath & keyPath)362 bool injectV8KeyIntoV8Value(v8::Isolate* isolate, v8::Handle<v8::Value> key, v8::Handle<v8::Value> value, const IDBKeyPath& keyPath)
363 {
364 IDB_TRACE("injectIDBV8KeyIntoV8Value");
365 ASSERT(isolate->InContext());
366
367 ASSERT(keyPath.type() == IDBKeyPath::StringType);
368 Vector<String> keyPathElements;
369 IDBKeyPathParseError error;
370 IDBParseKeyPath(keyPath.string(), keyPathElements, error);
371 ASSERT(error == IDBKeyPathParseErrorNone);
372
373 if (!keyPathElements.size())
374 return false;
375
376 v8::HandleScope handleScope(isolate);
377 v8::Handle<v8::Value> parent(ensureNthValueOnKeyPath(isolate, value, keyPathElements, keyPathElements.size() - 1));
378 if (parent.IsEmpty())
379 return false;
380
381 if (!set(isolate, parent, keyPathElements.last(), key))
382 return false;
383
384 return true;
385 }
386
canInjectIDBKeyIntoScriptValue(v8::Isolate * isolate,const ScriptValue & scriptValue,const IDBKeyPath & keyPath)387 bool canInjectIDBKeyIntoScriptValue(v8::Isolate* isolate, const ScriptValue& scriptValue, const IDBKeyPath& keyPath)
388 {
389 IDB_TRACE("canInjectIDBKeyIntoScriptValue");
390 ASSERT(keyPath.type() == IDBKeyPath::StringType);
391 Vector<String> keyPathElements;
392 IDBKeyPathParseError error;
393 IDBParseKeyPath(keyPath.string(), keyPathElements, error);
394 ASSERT(error == IDBKeyPathParseErrorNone);
395
396 if (!keyPathElements.size())
397 return false;
398
399 v8::Handle<v8::Value> v8Value(scriptValue.v8Value());
400 return canInjectNthValueOnKeyPath(isolate, v8Value, keyPathElements, keyPathElements.size() - 1);
401 }
402
idbAnyToScriptValue(ScriptState * scriptState,IDBAny * any)403 ScriptValue idbAnyToScriptValue(ScriptState* scriptState, IDBAny* any)
404 {
405 v8::Isolate* isolate = scriptState->isolate();
406 v8::HandleScope handleScope(isolate);
407 v8::Handle<v8::Value> v8Value(toV8(any, scriptState->context()->Global(), isolate));
408 return ScriptValue(scriptState, v8Value);
409 }
410
idbKeyToScriptValue(ScriptState * scriptState,IDBKey * key)411 ScriptValue idbKeyToScriptValue(ScriptState* scriptState, IDBKey* key)
412 {
413 v8::Isolate* isolate = scriptState->isolate();
414 v8::HandleScope handleScope(isolate);
415 v8::Handle<v8::Value> v8Value(toV8(key, scriptState->context()->Global(), isolate));
416 return ScriptValue(scriptState, v8Value);
417 }
418
scriptValueToIDBKey(v8::Isolate * isolate,const ScriptValue & scriptValue)419 IDBKey* scriptValueToIDBKey(v8::Isolate* isolate, const ScriptValue& scriptValue)
420 {
421 ASSERT(isolate->InContext());
422 v8::HandleScope handleScope(isolate);
423 v8::Handle<v8::Value> v8Value(scriptValue.v8Value());
424 return createIDBKeyFromValue(isolate, v8Value);
425 }
426
scriptValueToIDBKeyRange(v8::Isolate * isolate,const ScriptValue & scriptValue)427 IDBKeyRange* scriptValueToIDBKeyRange(v8::Isolate* isolate, const ScriptValue& scriptValue)
428 {
429 v8::HandleScope handleScope(isolate);
430 v8::Handle<v8::Value> value(scriptValue.v8Value());
431 return V8IDBKeyRange::toNativeWithTypeCheck(isolate, value);
432 }
433
434 #ifndef NDEBUG
assertPrimaryKeyValidOrInjectable(ScriptState * scriptState,PassRefPtr<SharedBuffer> buffer,const Vector<blink::WebBlobInfo> * blobInfo,IDBKey * key,const IDBKeyPath & keyPath)435 void assertPrimaryKeyValidOrInjectable(ScriptState* scriptState, PassRefPtr<SharedBuffer> buffer, const Vector<blink::WebBlobInfo>* blobInfo, IDBKey* key, const IDBKeyPath& keyPath)
436 {
437 ScriptState::Scope scope(scriptState);
438 v8::Isolate* isolate = scriptState->isolate();
439 ScriptValue keyValue = idbKeyToScriptValue(scriptState, key);
440 ScriptValue scriptValue(scriptState, deserializeIDBValueBuffer(isolate, buffer.get(), blobInfo));
441
442 // This assertion is about already persisted data, so allow experimental types.
443 const bool allowExperimentalTypes = true;
444 IDBKey* expectedKey = createIDBKeyFromScriptValueAndKeyPathInternal(isolate, scriptValue, keyPath, allowExperimentalTypes);
445 ASSERT(!expectedKey || expectedKey->isEqual(key));
446
447 bool injected = injectV8KeyIntoV8Value(isolate, keyValue.v8Value(), scriptValue.v8Value(), keyPath);
448 ASSERT_UNUSED(injected, injected);
449 }
450 #endif
451
452 } // namespace WebCore
453