[bindings] Remove SQLTransaction's usage of custom binding.

Source/bindings/modules/v8/V8BindingForModules.cpp

Index: Source/bindings/modules/v8/V8BindingForModules.cpp
diff --git a/Source/bindings/modules/v8/V8BindingForModules.cpp b/Source/bindings/modules/v8/V8BindingForModules.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3fef7fe0fe3201ccb199506895081ecbe66d60ac
--- /dev/null
+++ b/Source/bindings/modules/v8/V8BindingForModules.cpp
@@ -0,0 +1,34 @@
+// Copyright (c) 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "config.h"
+#include "bindings/modules/v8/V8BindingForModules.h"
+
+#include "bindings/core/v8/V8Binding.h"
+#include "modules/webdatabase/sqlite/SQLValue.h"
+
+namespace blink {
+
+Vector<SQLValue> toSQLValueArray(const Nullable<Vector<ScriptValue>>& values)

[Jens Widell, 2015/03/05 13:54:37]

I think toSQLValueArray(const Vector<ScriptValue>>&) makes more sense, leaving
the Nullable<>/isNull() stuff in the caller. The caller can trivially construct
an empty Vector<SQLValue> for the null case, after all.

Actually, it might make even more sense to have toSQLValue(const ScriptValue&),
and do the looping in the caller.

[bashi, 2015/03/06 00:52:58]

We might want to have more generic one like following (omitting error handling):

template <typename T>
Vector<T> toImplArray(v8::Isolate* isolate, Vector<ScriptValue> v,
ExceptionState es) {
  Vector<T> ret;
  for (unsigned i = 0; i < v.size(); ++i) {
    ret.uncheckedAppend(NativeValueTraits<T>::nativeValue(v[i].v8Value(),
isolate, es));
  }
  return ret;
}

template<>
struct NativeValueTraits<SQLValue> {
  static SQLValue nativeValue(const v8::Local<v8::Value>& value, v8::Isolate*
isolate, ExceptionState& es) {
    if (value.IsEmpty() || value->IsNull())
      return SQLValue();
    if (value->IsNumber())
      return value->NumberValue(); // This is going to be deprecated BTW
    V8StringResource<> stringValue(value);
    if (!stringValue.prepare(es))
      return SQLValue();
    return stringValue;
  }
};

It toImplArray() should be in V8Binding.h

+{
+    if (values.isNull())
+        return Vector<SQLValue>();
+
+    Vector<SQLValue> sqlValues;
+    const Vector<ScriptValue>& arguments = values.get();
+    for (unsigned i = 0; i < arguments.size(); ++i) {
+        const v8::Local<v8::Value>& arg = arguments[i].v8Value();
+        if (arg.IsEmpty() || arg->IsNull()) {
+            sqlValues.append(SQLValue());
+        } else if (arg->IsNumber()) {
+            sqlValues.append(SQLValue(arg->NumberValue()));
+        } else {
+            TOSTRING_DEFAULT(V8StringResource<>, stringValue, arg, Vector<SQLValue>());

[Jens Widell, 2015/03/05 13:54:38]

Exception handling is wrong here. This function should take an "ExceptionState&
exceptionState" argument, and then the code here should be

  V8StringResource<> stringValue(arg);
  if (!stringValue.prepare(exceptionState))
    return Vector<SQLValue>();

+            sqlValues.append(SQLValue(stringValue));
+        }
+    }
+    return sqlValues;
+}
+
+} // namespace blink