[bindings] Utilize ScriptValue::from and remove IDB* => ScriptValue conversion methods

Source/bindings/modules/v8/V8BindingForModules.cpp

 /*
  * Copyright (C) 2011 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 15 matching lines @@
 #include "config.h"
 #include "bindings/modules/v8/V8BindingForModules.h"
 
 #include "bindings/core/v8/SerializedScriptValue.h"
 #include "bindings/core/v8/SerializedScriptValueFactory.h"
 #include "bindings/core/v8/V8ArrayBufferView.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8DOMStringList.h"
 #include "bindings/core/v8/V8HiddenValue.h"
 #include "bindings/core/v8/V8Uint8Array.h"
+#include "bindings/modules/v8/ToV8ForModules.h"
 #include "bindings/modules/v8/V8IDBCursor.h"
 #include "bindings/modules/v8/V8IDBCursorWithValue.h"
 #include "bindings/modules/v8/V8IDBDatabase.h"
 #include "bindings/modules/v8/V8IDBIndex.h"
 #include "bindings/modules/v8/V8IDBKeyRange.h"
 #include "bindings/modules/v8/V8IDBObjectStore.h"
 #include "bindings/modules/v8/V8IDBRequest.h"
 #include "modules/indexeddb/IDBKey.h"
 #include "modules/indexeddb/IDBKeyPath.h"
 #include "modules/indexeddb/IDBKeyRange.h"
 #include "modules/indexeddb/IDBTracing.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/SharedBuffer.h"
 #include "wtf/MathExtras.h"
 #include "wtf/Vector.h"
 
 namespace blink {
 
 static v8::Local<v8::Value> deserializeIDBValueBuffer(v8::Isolate*, SharedBuffer*, const Vector<blink::WebBlobInfo>*);
 
-static v8::Local<v8::Value> toV8(const IDBKeyPath& value, v8::Local<v8::Object> creationContext, v8::Isolate* isolate)
+v8::Local<v8::Value> toV8(const IDBKeyPath& value, v8::Local<v8::Object> creationContext, v8::Isolate* isolate)
 {
     switch (value.type()) {
     case IDBKeyPath::NullType:
         return v8::Null(isolate);
     case IDBKeyPath::StringType:
         return v8String(isolate, value.string());
     case IDBKeyPath::ArrayType:
         RefPtrWillBeRawPtr<DOMStringList> keyPaths = DOMStringList::create();
         for (Vector<String>::const_iterator it = value.array().begin(); it != value.array().end(); ++it)
             keyPaths->append(*it);
         return toV8(keyPaths.release(), creationContext, isolate);
     }
     ASSERT_NOT_REACHED();
     return v8::Undefined(isolate);
 }
 
-static v8::Local<v8::Value> toV8(const IDBKey* key, v8::Local<v8::Object> creationContext, v8::Isolate* isolate)
+v8::Local<v8::Value> toV8(const IDBKey* key, v8::Local<v8::Object> creationContext, v8::Isolate* isolate)
 {
     if (!key) {
         // This should be undefined, not null.
         // Spec: http://dvcs.w3.org/hg/IndexedDB/raw-file/tip/Overview.html#idl-def-IDBKeyRange
         return v8Undefined();
     }
 
     switch (key->type()) {
     case IDBKey::InvalidType:
     case IDBKey::MinType:
@@ skipping 13 matching lines @@
             for (size_t i = 0; i < key->array().size(); ++i)
                 array->Set(i, toV8(key->array()[i].get(), creationContext, isolate));
             return array;
         }
     }
 
     ASSERT_NOT_REACHED();
     return v8Undefined();
 }
 
-static v8::Local<v8::Value> toV8(const IDBAny* impl, v8::Local<v8::Object> creationContext, v8::Isolate* isolate)
+v8::Local<v8::Value> toV8(const IDBAny* impl, v8::Local<v8::Object> creationContext, v8::Isolate* isolate)
 {
     if (!impl)
         return v8::Null(isolate);
 
     switch (impl->type()) {
     case IDBAny::UndefinedType:
         return v8::Undefined(isolate);
     case IDBAny::NullType:
         return v8::Null(isolate);
     case IDBAny::DOMStringListType:
@@ skipping 273 matching lines @@
     IDBParseKeyPath(keyPath.string(), keyPathElements, error);
     ASSERT(error == IDBKeyPathParseErrorNone);
 
     if (!keyPathElements.size())
         return false;
 
     v8::Local<v8::Value> v8Value(scriptValue.v8Value());
     return canInjectNthValueOnKeyPath(isolate, v8Value, keyPathElements, keyPathElements.size() - 1);
 }
 
-ScriptValue idbAnyToScriptValue(ScriptState* scriptState, IDBAny* any)
-{
-    v8::Isolate* isolate = scriptState->isolate();
-    v8::HandleScope handleScope(isolate);

[haraken, 2015/03/13 12:48:10]

The previous code was creating a HandleScope before converting the value, but
the new code isn't. I hope this is fine (because we'll have a HandleScope
somewhere above in the stack) but please check that all tests pass before
landing the CL.

-    v8::Local<v8::Value> v8Value(toV8(any, scriptState->context()->Global(), isolate));
-    return ScriptValue(scriptState, v8Value);
-}
-
-ScriptValue idbKeyToScriptValue(ScriptState* scriptState, const IDBKey* key)
-{
-    v8::Isolate* isolate = scriptState->isolate();
-    v8::HandleScope handleScope(isolate);
-    v8::Local<v8::Value> v8Value(toV8(key, scriptState->context()->Global(), isolate));
-    return ScriptValue(scriptState, v8Value);
-}
-
-ScriptValue idbKeyPathToScriptValue(ScriptState* scriptState, const IDBKeyPath& keyPath)
-{
-    v8::Isolate* isolate = scriptState->isolate();
-    v8::HandleScope handleScope(isolate);
-    v8::Local<v8::Value> v8Value(toV8(keyPath, scriptState->context()->Global(), isolate));
-    return ScriptValue(scriptState, v8Value);
-}
-
 IDBKey* scriptValueToIDBKey(v8::Isolate* isolate, const ScriptValue& scriptValue)

[haraken, 2015/03/13 12:48:10]

Can we now remove this?

 {
     ASSERT(isolate->InContext());
     v8::HandleScope handleScope(isolate);
     v8::Local<v8::Value> v8Value(scriptValue.v8Value());
     return createIDBKeyFromValue(isolate, v8Value);
 }
 
 IDBKeyRange* scriptValueToIDBKeyRange(v8::Isolate* isolate, const ScriptValue& scriptValue)

[haraken, 2015/03/13 12:48:10]

Can we now remove this?

 {
     v8::HandleScope handleScope(isolate);
     v8::Local<v8::Value> value(scriptValue.v8Value());
     return V8IDBKeyRange::toImplWithTypeCheck(isolate, value);
 }
 
 ScriptValue deserializeScriptValue(ScriptState* scriptState, SerializedScriptValue* serializedValue, const Vector<blink::WebBlobInfo>* blobInfo)
 {
     v8::Isolate* isolate = scriptState->isolate();
     v8::HandleScope handleScope(isolate);
     if (serializedValue)
         return ScriptValue(scriptState, serializedValue->deserialize(isolate, 0, blobInfo));
     return ScriptValue(scriptState, v8::Null(isolate));
 }
 
+SQLValue NativeValueTraits<SQLValue>::nativeValue(const v8::Local<v8::Value>& value, v8::Isolate* isolate, ExceptionState& exceptionState)
+{
+    if (value.IsEmpty() || value->IsNull())
+        return SQLValue();
+    if (value->IsNumber())
+        return SQLValue(value->NumberValue());
+    V8StringResource<> stringValue(value);
+    if (!stringValue.prepare(exceptionState))
+        return SQLValue();
+    return SQLValue(stringValue);
+}
+
+IDBKey* NativeValueTraits<IDBKey*>::nativeValue(const v8::Local<v8::Value>& value, v8::Isolate* isolate, ExceptionState& exceptionState)
+{
+    return createIDBKeyFromValue(isolate, value);
+}
+
+IDBKeyRange* NativeValueTraits<IDBKeyRange*>::nativeValue(const v8::Local<v8::Value>& value, v8::Isolate* isolate, ExceptionState& exceptionState)
+{
+    return V8IDBKeyRange::toImplWithTypeCheck(isolate, value);
+}
+
 #if ENABLE(ASSERT)
 void assertPrimaryKeyValidOrInjectable(ScriptState* scriptState, PassRefPtr<SharedBuffer> buffer, const Vector<blink::WebBlobInfo>* blobInfo, IDBKey* key, const IDBKeyPath& keyPath)
 {
     ScriptState::Scope scope(scriptState);
     v8::Isolate* isolate = scriptState->isolate();
-    ScriptValue keyValue = idbKeyToScriptValue(scriptState, key);
+    ScriptValue keyValue = ScriptValue::from(scriptState, key);
     ScriptValue scriptValue(scriptState, deserializeIDBValueBuffer(isolate, buffer.get(), blobInfo));
 
     // This assertion is about already persisted data, so allow experimental types.
     const bool allowExperimentalTypes = true;
     IDBKey* expectedKey = createIDBKeyFromScriptValueAndKeyPathInternal(isolate, scriptValue, keyPath, allowExperimentalTypes);
     ASSERT(!expectedKey || expectedKey->isEqual(key));
 
     bool injected = injectV8KeyIntoV8Value(isolate, keyValue.v8Value(), scriptValue.v8Value(), keyPath);
     ASSERT_UNUSED(injected, injected);
 }
 #endif
 
 } // namespace blink