WIP bindings: Add support for the record<K,V> WebIDL type.

third_party/WebKit/Source/bindings/core/v8/IDLTypes.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 IDLTypes_h
+#define IDLTypes_h
+
+#include <type_traits>
+#include "bindings/core/v8/NativeValueTraits.h"
+#include "bindings/core/v8/SerializedScriptValue.h"
+#include "bindings/core/v8/V8Binding.h"
+#include "core/CoreExport.h"
+#include "platform/heap/Handle.h"
+#include "wtf/TypeTraits.h"
+#include "wtf/text/WTFString.h"
+
+namespace blink {
+
+namespace idl {

[Yuki, 2017/03/02 07:47:28]

Do we have a consensus to introduce a new nested namespace "idl"?
If not, I'd recommend to get agreement on platform-architecture-dev@chromium.org
.

By the way, I'd slightly prefer "webidl" just in case that we'll have another
IDL.

[Raphael Kubo da Costa (rakuco), 2017/03/02 08:16:24]

We don't, I introduced this namespace while writing the code to see if it would
work. I'm also OK with following what WebKit does and just calling the types
"IDLFoo" if you prefer.

[Yuki, 2017/03/02 13:00:24]

I'm fine with either way.  "IDLFoo" seems okay to me, too.

+
+struct CORE_EXPORT Boolean final {};
+
+struct CORE_EXPORT Byte final {};
+struct CORE_EXPORT Octet final {};
+struct CORE_EXPORT Short final {};
+struct CORE_EXPORT UnsignedShort final {};
+struct CORE_EXPORT Long final {};
+struct CORE_EXPORT UnsignedLong final {};
+struct CORE_EXPORT LongLong final {};
+struct CORE_EXPORT UnsignedLongLong final {};
+
+struct CORE_EXPORT ByteString final {};
+struct CORE_EXPORT String final {};
+struct CORE_EXPORT USVString final {};
+
+struct CORE_EXPORT Double final {};
+struct CORE_EXPORT UnrestrictedDouble final {};
+
+struct CORE_EXPORT Float final {};
+struct CORE_EXPORT UnrestrictedFloat final {};
+
+struct CORE_EXPORT Date final {};
+
+struct CORE_EXPORT Promise final {};
+
+template <typename SequenceType>
+struct CORE_EXPORT Sequence final {};
+
+template <typename KeyType, typename ValueType>
+struct CORE_EXPORT Record final {};
+
+}  // namespace idl
+
+class DOMWindow;
+
+// Boolean
+// -------
+template <>
+struct NativeValueTraits<idl::Boolean> {
+  using ImplType = bool;
+
+  CORE_EXPORT static inline bool nativeValue(v8::Isolate* isolate,
+                                             v8::Local<v8::Value> value,
+                                             ExceptionState& exceptionState) {
+    return toBoolean(isolate, value, exceptionState);
+  }
+};
+
+// Integers
+// --------
+template <>
+struct NativeValueTraits<idl::Byte> {
+  using ImplType = int8_t;
+
+  CORE_EXPORT static inline int8_t nativeValue(
+      v8::Isolate* isolate,
+      v8::Local<v8::Value> value,
+      ExceptionState& exceptionState,
+      IntegerConversionConfiguration conversionMode = NormalConversion) {
+    return toInt8(isolate, value, conversionMode, exceptionState);
+  }
+};
+
+template <>
+struct NativeValueTraits<idl::Octet> {
+  using ImplType = uint8_t;
+
+  CORE_EXPORT static inline uint8_t nativeValue(
+      v8::Isolate* isolate,
+      v8::Local<v8::Value> value,
+      ExceptionState& exceptionState,
+      IntegerConversionConfiguration conversionMode = NormalConversion) {
+    return toUInt8(isolate, value, conversionMode, exceptionState);
+  }
+};
+
+template <>
+struct NativeValueTraits<idl::Short> {
+  using ImplType = int16_t;
+
+  CORE_EXPORT static inline int16_t nativeValue(
+      v8::Isolate* isolate,
+      v8::Local<v8::Value> value,
+      ExceptionState& exceptionState,
+      IntegerConversionConfiguration conversionMode = NormalConversion) {
+    return toInt16(isolate, value, conversionMode, exceptionState);
+  }
+};
+
+template <>
+struct NativeValueTraits<idl::UnsignedShort> {
+  using ImplType = uint16_t;
+
+  CORE_EXPORT static inline uint16_t nativeValue(
+      v8::Isolate* isolate,
+      v8::Local<v8::Value> value,
+      ExceptionState& exceptionState,
+      IntegerConversionConfiguration conversionMode = NormalConversion) {
+    return toUInt16(isolate, value, conversionMode, exceptionState);
+  }
+};
+
+template <>
+struct NativeValueTraits<idl::Long> {
+  using ImplType = int32_t;
+
+  CORE_EXPORT static inline int32_t nativeValue(
+      v8::Isolate* isolate,
+      v8::Local<v8::Value> value,
+      ExceptionState& exceptionState,
+      IntegerConversionConfiguration conversionMode = NormalConversion) {
+    return toInt32(isolate, value, conversionMode, exceptionState);
+  }
+};
+
+template <>
+struct NativeValueTraits<idl::UnsignedLong> {
+  using ImplType = uint32_t;
+
+  CORE_EXPORT static inline uint32_t nativeValue(
+      v8::Isolate* isolate,
+      v8::Local<v8::Value> value,
+      ExceptionState& exceptionState,
+      IntegerConversionConfiguration conversionMode = NormalConversion) {
+    return toUInt32(isolate, value, conversionMode, exceptionState);
+  }
+};
+
+template <>
+struct NativeValueTraits<idl::LongLong> {
+  using ImplType = int64_t;
+
+  CORE_EXPORT static inline int64_t nativeValue(
+      v8::Isolate* isolate,
+      v8::Local<v8::Value> value,
+      ExceptionState& exceptionState,
+      IntegerConversionConfiguration conversionMode = NormalConversion) {
+    return toInt64(isolate, value, conversionMode, exceptionState);
+  }
+};
+
+template <>
+struct NativeValueTraits<idl::UnsignedLongLong> {
+  using ImplType = uint64_t;
+
+  CORE_EXPORT static inline uint64_t nativeValue(
+      v8::Isolate* isolate,
+      v8::Local<v8::Value> value,
+      ExceptionState& exceptionState,
+      IntegerConversionConfiguration conversionMode = NormalConversion) {
+    return toUInt64(isolate, value, conversionMode, exceptionState);
+  }
+};
+
+// Strings
+// -------
+template <>
+struct NativeValueTraits<idl::ByteString> {
+  using ImplType = String;
+
+  CORE_EXPORT static inline String nativeValue(v8::Isolate* isolate,
+                                               v8::Local<v8::Value> value,
+                                               ExceptionState& exceptionState) {
+    return toByteString(isolate, value, exceptionState);
+  }
+};
+
+template <>
+struct NativeValueTraits<idl::String> {
+  using ImplType = String;
+
+  template <V8StringResourceMode Mode = DefaultMode>
+  CORE_EXPORT static inline String nativeValue(v8::Isolate* isolate,
+                                               v8::Local<v8::Value> value,
+                                               ExceptionState& exceptionState) {
+    V8StringResource<Mode> s(value);
+    if (!s.prepare(isolate, exceptionState))
+      return String();
+    return s;
+  }
+};
+
+template <>
+struct NativeValueTraits<idl::USVString> {
+  using ImplType = String;
+
+  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<idl::Double> {
+  using ImplType = double;
+
+  CORE_EXPORT static inline double nativeValue(v8::Isolate* isolate,
+                                               v8::Local<v8::Value> value,
+                                               ExceptionState& exceptionState) {
+    return toRestrictedDouble(isolate, value, exceptionState);
+  }
+};
+
+template <>
+struct NativeValueTraits<idl::UnrestrictedDouble> {
+  using ImplType = double;
+
+  CORE_EXPORT static inline double nativeValue(v8::Isolate* isolate,
+                                               v8::Local<v8::Value> value,
+                                               ExceptionState& exceptionState) {
+    return toDouble(isolate, value, exceptionState);
+  }
+};
+
+template <>
+struct NativeValueTraits<idl::Float> {
+  using ImplType = float;
+
+  CORE_EXPORT static inline float nativeValue(v8::Isolate* isolate,
+                                              v8::Local<v8::Value> value,
+                                              ExceptionState& exceptionState) {
+    return toRestrictedFloat(isolate, value, exceptionState);
+  }
+};
+
+template <>
+struct NativeValueTraits<idl::UnrestrictedFloat> {
+  using ImplType = float;
+
+  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<idl::Promise> {
+  using ImplType = ScriptPromise;
+  static inline ScriptPromise nativeValue(v8::Isolate* isolate,
+                                          v8::Local<v8::Value> value,
+                                          ExceptionState& exceptionState) {
+    return ScriptPromise::cast(ScriptState::current(isolate), value);
+  }
+};
+
+// Type-specific overloads.
+// ------------------------
+template <>
+struct NativeValueTraits<DOMWindow> {
+  using ImplType = DOMWindow;
+
+  CORE_EXPORT static inline DOMWindow* nativeValue(
+      v8::Isolate* isolate,
+      v8::Local<v8::Value> value,
+      ExceptionState& exceptionState) {
+    return toDOMWindow(isolate, value);
+  }
+};
+
+template <>
+struct NativeValueTraits<SerializedScriptValue> {
+  using ImplType = 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);
+  }
+};
+
+template <>
+struct NativeValueTraits<idl::Date> {
+  using ImplType = double;
+
+  CORE_EXPORT static inline double nativeValue(v8::Isolate* isolate,
+                                               v8::Local<v8::Value> value,
+                                               ExceptionState& exceptionState) {
+    return toCoreDate(isolate, value, exceptionState);
+  }
+};
+
+template <typename T>
+struct NativeValueTraits<Member<T>> {
+  using ImplType = Member<T>;
+
+  CORE_EXPORT static inline T* nativeValue(v8::Isolate* isolate,
+                                           v8::Local<v8::Value> value,
+                                           ExceptionState& exceptionState) {
+    return NativeValueTraits<T>::nativeValue(isolate, value, exceptionState);
+  }
+};
+
+template <typename T>
+struct NativeValueTraits<T> {
+  using ImplType = T;
+
+  CORE_EXPORT static inline T* nativeValue(v8::Isolate* isolate,
+                                           v8::Local<v8::Value> value,
+                                           ExceptionState& exceptionState) {
+    return V8TypeOf<T>::Type::toImplWithTypeCheck(isolate, value);
+  }
+};
+
+// Type helpers
+// ------------
+template <typename T>
+struct MaybeWrapped {
+  using ImplType = typename std::
+      conditional<WTF::IsGarbageCollectedType<T>::value, Member<T>, T>::type;
+};
+
+template <typename T>
+struct NeedsHeapVector {
+  static const bool value = WTF::IsGarbageCollectedType<T>::value ||
+                            std::is_class<typename V8TypeOf<T>::Type>::value;
+};
+
+// Sequences
+// ---------
+template <typename T>
+struct NativeValueTraits<idl::Sequence<T>> {
+ private:
+  using CppType = typename NativeValueTraits<T>::ImplType;
+  using MaybeWrappedCppType = typename MaybeWrapped<CppType>::ImplType;
+
+ public:
+  using ImplType = typename std::conditional<NeedsHeapVector<CppType>::value,
+                                             HeapVector<MaybeWrappedCppType>,
+                                             Vector<MaybeWrappedCppType>>::type;
+
+  CORE_EXPORT static inline ImplType nativeValue(v8::Isolate* isolate,
+                                                 v8::Local<v8::Value> value,
+                                                 ExceptionState& exceptionState,
+                                                 int index = 0) {
+    return toImplArray<ImplType, T>(value, index, isolate, exceptionState);
+  }
+};
+
+// Records
+// -------
+template <typename K, typename V>
+struct NativeValueTraits<idl::Record<K, V>> {
+ private:
+  using ValueCppType = typename NativeValueTraits<V>::ImplType;
+  using MaybeWrappedValueCppType =
+      typename MaybeWrapped<ValueCppType>::ImplType;
+
+ public:
+  using ImplType = typename std::conditional<
+      NeedsHeapVector<ValueCppType>::value,
+      HeapVector<std::pair<String, MaybeWrappedValueCppType>>,
+      Vector<std::pair<String, MaybeWrappedValueCppType>>>::type;
+
+  CORE_EXPORT static inline ImplType nativeValue(
+      v8::Isolate* isolate,
+      v8::Local<v8::Value> value,
+      ExceptionState& exceptionState) {
+    return toImplRecord<K, V, ImplType>(isolate, value, exceptionState);
+  }
+};
+
+}  // namespace blink
+
+#endif  // IDLTypes_h