bindings: Add C++ versions of WebIDL types and generalize NativeValueTraits.

third_party/WebKit/Source/bindings/core/v8/NativeValueTraitsImpl.h

+// Copyright (c) 2017 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.
+
+#ifndef NativeValueTraitsImpl_h
+#define NativeValueTraitsImpl_h
+
+#include "bindings/core/v8/IDLTypes.h"
+#include "bindings/core/v8/NativeValueTraits.h"
+#include "bindings/core/v8/SerializedScriptValue.h"
+#include "bindings/core/v8/V8Binding.h"
+#include "core/CoreExport.h"
+#include "wtf/text/WTFString.h"
+
+namespace blink {
+
+// Boolean
+template <>
+struct NativeValueTraits<IDLBoolean>
+    : public NativeValueTraitsBase<IDLBoolean> {
+  CORE_EXPORT static inline bool nativeValue(v8::Isolate* isolate,
+                                             v8::Local<v8::Value> value,
+                                             ExceptionState& exceptionState) {
+    return toBoolean(isolate, value, exceptionState);
+  }
+};
+
+// Integers
+//
+// All integer specializations offer a second nativeValue() besides the default
+// one: it takes an IntegerConversionConfiguration argument to let callers
+// specify how the integers should be converted. The default nativeValue()
+// overload will always use NormalConversion.
+template <>
+struct NativeValueTraits<IDLByte> : public NativeValueTraitsBase<IDLByte> {
+  CORE_EXPORT static inline int8_t nativeValue(v8::Isolate* isolate,
+                                               v8::Local<v8::Value> value,
+                                               ExceptionState& exceptionState) {
+    return nativeValue(isolate, value, exceptionState, NormalConversion);
+  }
+
+  CORE_EXPORT static inline int8_t nativeValue(
+      v8::Isolate* isolate,
+      v8::Local<v8::Value> value,
+      ExceptionState& exceptionState,
+      IntegerConversionConfiguration conversionMode) {
+    return toInt8(isolate, value, conversionMode, exceptionState);
+  }
+};
+
+template <>
+struct NativeValueTraits<IDLOctet> : public NativeValueTraitsBase<IDLOctet> {
+  CORE_EXPORT static inline uint8_t nativeValue(
+      v8::Isolate* isolate,
+      v8::Local<v8::Value> value,
+      ExceptionState& exceptionState) {
+    return nativeValue(isolate, value, exceptionState, NormalConversion);
+  }
+
+  CORE_EXPORT static inline uint8_t nativeValue(
+      v8::Isolate* isolate,
+      v8::Local<v8::Value> value,
+      ExceptionState& exceptionState,
+      IntegerConversionConfiguration conversionMode) {
+    return toUInt8(isolate, value, conversionMode, exceptionState);
+  }
+};
+
+template <>
+struct NativeValueTraits<IDLShort> : public NativeValueTraitsBase<IDLShort> {
+  CORE_EXPORT static inline int16_t nativeValue(
+      v8::Isolate* isolate,
+      v8::Local<v8::Value> value,
+      ExceptionState& exceptionState) {
+    return nativeValue(isolate, value, exceptionState, NormalConversion);
+  }
+
+  CORE_EXPORT static inline int16_t nativeValue(
+      v8::Isolate* isolate,
+      v8::Local<v8::Value> value,
+      ExceptionState& exceptionState,
+      IntegerConversionConfiguration conversionMode) {
+    return toInt16(isolate, value, conversionMode, exceptionState);
+  }
+};
+
+template <>
+struct NativeValueTraits<IDLUnsignedShort>
+    : public NativeValueTraitsBase<IDLUnsignedShort> {
+  CORE_EXPORT static inline uint16_t nativeValue(
+      v8::Isolate* isolate,
+      v8::Local<v8::Value> value,
+      ExceptionState& exceptionState) {
+    return nativeValue(isolate, value, exceptionState, NormalConversion);
+  }
+
+  CORE_EXPORT static inline uint16_t nativeValue(
+      v8::Isolate* isolate,
+      v8::Local<v8::Value> value,
+      ExceptionState& exceptionState,
+      IntegerConversionConfiguration conversionMode) {
+    return toUInt16(isolate, value, conversionMode, exceptionState);
+  }
+};
+
+template <>
+struct NativeValueTraits<IDLLong> : public NativeValueTraitsBase<IDLLong> {
+  CORE_EXPORT static inline int32_t nativeValue(
+      v8::Isolate* isolate,
+      v8::Local<v8::Value> value,
+      ExceptionState& exceptionState) {
+    return nativeValue(isolate, value, exceptionState, NormalConversion);
+  }
+
+  CORE_EXPORT static inline int32_t nativeValue(
+      v8::Isolate* isolate,
+      v8::Local<v8::Value> value,
+      ExceptionState& exceptionState,
+      IntegerConversionConfiguration conversionMode) {
+    return toInt32(isolate, value, conversionMode, exceptionState);
+  }
+};
+
+template <>
+struct NativeValueTraits<IDLUnsignedLong>
+    : public NativeValueTraitsBase<IDLUnsignedLong> {
+  CORE_EXPORT static inline uint32_t nativeValue(
+      v8::Isolate* isolate,
+      v8::Local<v8::Value> value,
+      ExceptionState& exceptionState) {
+    return nativeValue(isolate, value, exceptionState, NormalConversion);
+  }
+
+  CORE_EXPORT static inline uint32_t nativeValue(
+      v8::Isolate* isolate,
+      v8::Local<v8::Value> value,
+      ExceptionState& exceptionState,
+      IntegerConversionConfiguration conversionMode) {
+    return toUInt32(isolate, value, conversionMode, exceptionState);
+  }
+};
+
+template <>
+struct NativeValueTraits<IDLLongLong>
+    : public NativeValueTraitsBase<IDLLongLong> {
+  CORE_EXPORT static inline int64_t nativeValue(
+      v8::Isolate* isolate,
+      v8::Local<v8::Value> value,
+      ExceptionState& exceptionState) {
+    return nativeValue(isolate, value, exceptionState, NormalConversion);
+  }
+
+  CORE_EXPORT static inline int64_t nativeValue(
+      v8::Isolate* isolate,
+      v8::Local<v8::Value> value,
+      ExceptionState& exceptionState,
+      IntegerConversionConfiguration conversionMode) {
+    return toInt64(isolate, value, conversionMode, exceptionState);
+  }
+};
+
+template <>
+struct NativeValueTraits<IDLUnsignedLongLong>
+    : public NativeValueTraitsBase<IDLUnsignedLongLong> {
+  CORE_EXPORT static inline uint64_t nativeValue(
+      v8::Isolate* isolate,
+      v8::Local<v8::Value> value,
+      ExceptionState& exceptionState) {
+    return nativeValue(isolate, value, exceptionState, NormalConversion);
+  }
+
+  CORE_EXPORT static inline uint64_t nativeValue(
+      v8::Isolate* isolate,
+      v8::Local<v8::Value> value,
+      ExceptionState& exceptionState,
+      IntegerConversionConfiguration conversionMode) {
+    return toUInt64(isolate, value, conversionMode, exceptionState);
+  }
+};
+
+// Strings
+template <>
+struct NativeValueTraits<IDLByteString>
+    : public NativeValueTraitsBase<IDLByteString> {
+  CORE_EXPORT static inline String nativeValue(v8::Isolate* isolate,
+                                               v8::Local<v8::Value> value,
+                                               ExceptionState& exceptionState) {
+    return toByteString(isolate, value, exceptionState);
+  }
+};
+
+template <>
+struct NativeValueTraits<IDLString> : public NativeValueTraitsBase<IDLString> {
+  CORE_EXPORT static inline String nativeValue(v8::Isolate* isolate,
+                                               v8::Local<v8::Value> value,
+                                               ExceptionState& exceptionState) {
+    return nativeValue<V8StringResourceMode::DefaultMode>(isolate, value,

[haraken, 2017/03/06 12:56:33]

Just to confirm: Using the DefaultMode doesn't change the existing behavior,
right?

[Raphael Kubo da Costa (rakuco), 2017/03/06 14:29:17]

Right, that's what the specialization for WTF::String in V8Binding.h also does.

However, note that DOMStrings (aka IDLString) have not been converted to
NativeValueTraits in v8_types.py for now because the Python code first needs to
be adapted to handle these different modes (it currently does so with
V8StringResource directly).

+                                                          exceptionState);
+  }
+
+  template <V8StringResourceMode Mode = DefaultMode>
+  CORE_EXPORT static inline String nativeValue(v8::Isolate* isolate,
+                                               v8::Local<v8::Value> value,
+                                               ExceptionState& exceptionState) {
+    V8StringResource<Mode> s(value);

[haraken, 2017/03/06 12:56:33]

s => string

[Raphael Kubo da Costa (rakuco), 2017/03/06 14:29:17]

Done.

+    if (!s.prepare(isolate, exceptionState))
+      return String();
+    return s;
+  }
+};
+
+template <>
+struct NativeValueTraits<IDLUSVString>
+    : public NativeValueTraitsBase<IDLUSVString> {
+  CORE_EXPORT static inline String nativeValue(v8::Isolate* isolate,
+                                               v8::Local<v8::Value> value,
+                                               ExceptionState& exceptionState) {
+    return toUSVString(isolate, value, exceptionState);
+  }
+};
+
+// Floats and doubles
+template <>
+struct NativeValueTraits<IDLDouble> : public NativeValueTraitsBase<IDLDouble> {
+  CORE_EXPORT static inline double nativeValue(v8::Isolate* isolate,
+                                               v8::Local<v8::Value> value,
+                                               ExceptionState& exceptionState) {
+    return toRestrictedDouble(isolate, value, exceptionState);
+  }
+};
+
+template <>
+struct NativeValueTraits<IDLUnrestrictedDouble>
+    : public NativeValueTraitsBase<IDLUnrestrictedDouble> {
+  CORE_EXPORT static inline double nativeValue(v8::Isolate* isolate,
+                                               v8::Local<v8::Value> value,
+                                               ExceptionState& exceptionState) {
+    return toDouble(isolate, value, exceptionState);
+  }
+};
+
+template <>
+struct NativeValueTraits<IDLFloat> : public NativeValueTraitsBase<IDLFloat> {
+  CORE_EXPORT static inline float nativeValue(v8::Isolate* isolate,
+                                              v8::Local<v8::Value> value,
+                                              ExceptionState& exceptionState) {
+    return toRestrictedFloat(isolate, value, exceptionState);
+  }
+};
+
+template <>
+struct NativeValueTraits<IDLUnrestrictedFloat>
+    : public NativeValueTraitsBase<IDLUnrestrictedFloat> {
+  CORE_EXPORT static inline float nativeValue(v8::Isolate* isolate,
+                                              v8::Local<v8::Value> value,
+                                              ExceptionState& exceptionState) {
+    return toFloat(isolate, value, exceptionState);
+  }
+};
+
+// Promises
+template <>
+struct NativeValueTraits<IDLPromise>
+    : public NativeValueTraitsBase<IDLPromise> {
+  CORE_EXPORT static inline ScriptPromise nativeValue(
+      v8::Isolate* isolate,
+      v8::Local<v8::Value> value,
+      ExceptionState& exceptionState) {
+    return nativeValue(isolate, value);

[haraken, 2017/03/06 12:56:33]

Is this used? If it's unused, we can add NOT_REACHED().

[Raphael Kubo da Costa (rakuco), 2017/03/06 14:29:17]

This one is supposed to be used by callers which have no information about the
type they need to use NativeValueTraits with: in this case, they just know they
need to pass those 3 parameters. If callers know they are handling a Promise,
they can invoke the second version below directly and avoid having to create an
ExceptionState that's not used (which was Yuki's original concern with
converting everything to NativeValueTraits).

+  }
+
+  CORE_EXPORT static inline ScriptPromise nativeValue(
+      v8::Isolate* isolate,
+      v8::Local<v8::Value> value) {
+    return ScriptPromise::cast(ScriptState::current(isolate), value);
+  }
+};
+
+// Type-specific overloads
+template <>
+struct NativeValueTraits<IDLDate> : public NativeValueTraitsBase<IDLDate> {
+  CORE_EXPORT static inline double nativeValue(v8::Isolate* isolate,
+                                               v8::Local<v8::Value> value,
+                                               ExceptionState& exceptionState) {
+    return toCoreDate(isolate, value, exceptionState);
+  }
+};
+
+template <>
+struct NativeValueTraits<SerializedScriptValue>
+    : public NativeValueTraitsBase<SerializedScriptValue> {
+  CORE_EXPORT static inline PassRefPtr<SerializedScriptValue> nativeValue(
+      v8::Isolate* isolate,
+      v8::Local<v8::Value> value,
+      ExceptionState& exceptionState) {
+    return SerializedScriptValue::serialize(isolate, value, nullptr, nullptr,
+                                            exceptionState);
+  }
+};
+
+// Generated IDL interfaces.
+template <typename T>
+struct NativeValueTraits<T,
+                         typename std::enable_if<std::is_class<
+                             typename V8TypeOf<T>::Type>::value>::type>

[haraken, 2017/03/06 12:56:33]

Add a comment about when enble_if ... returns true.

+    : public NativeValueTraitsBase<T> {
+  CORE_EXPORT static inline T* nativeValue(v8::Isolate* isolate,
+                                           v8::Local<v8::Value> value,
+                                           ExceptionState& exceptionState) {
+    return nativeValue(isolate, value);
+  }
+
+  CORE_EXPORT static inline T* nativeValue(v8::Isolate* isolate,
+                                           v8::Local<v8::Value> value) {
+    return V8TypeOf<T>::Type::toImplWithTypeCheck(isolate, value);

[haraken, 2017/03/06 12:56:33]

Just for the record, we should be careful not to use ::nativeValue in places
where we can just use toImpl (instead of toImplWithTypeCheck).

+  }
+};
+
+// Sequences
+template <typename T>
+struct NativeValueTraits<IDLSequence<T>>
+    : public NativeValueTraitsBase<IDLSequence<T>> {
+  // Nondependent types need to be explicitly qualified to be accessible.
+  using typename NativeValueTraitsBase<IDLSequence<T>>::ImplType;
+
+  CORE_EXPORT static inline ImplType nativeValue(
+      v8::Isolate* isolate,
+      v8::Local<v8::Value> value,
+      ExceptionState& exceptionState) {
+    return nativeValue(isolate, value, exceptionState, 0);
+  }
+
+  CORE_EXPORT static inline ImplType nativeValue(v8::Isolate* isolate,
+                                                 v8::Local<v8::Value> value,
+                                                 ExceptionState& exceptionState,
+                                                 int index) {
+    return toImplArray<ImplType, T>(value, index, isolate, exceptionState);
+  }
+};
+
+}  // namespace blink
+
+#endif  // NativeValueTraitsImpl_h