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/IDLTypesBase.h"
 #include "bindings/core/v8/NativeValueTraits.h"
@@ skipping 36 matching lines @@
 struct IDLDate final : public IDLBaseHelper<double> {};
 
 // Promise
 struct IDLPromise final : public IDLBaseHelper<ScriptPromise> {};
 
 // Sequence
 template <typename T>
 struct IDLSequence final : public IDLBase {
  private:
   using CppType = typename NativeValueTraits<T>::ImplType;
-  using MaybeWrappedCppType =
+  using MaybeMemberCppType =
       typename std::conditional<WTF::IsGarbageCollectedType<CppType>::value,
                                 Member<CppType>,
                                 CppType>::type;
 
  public:
   // Two kinds of types need HeapVector:
   // 1. Oilpan types, which are wrapped by Member<>.
   // 2. IDL unions and dictionaries, which are not Oilpan types themselves (and
   //    are thus not wrapped by Member<>) but have a trace() method and can
   //    contain Oilpan members. They both also happen to specialize V8TypeOf,
   //    which we use to recognize them.
   using ImplType = typename std::conditional<
-      std::is_same<MaybeWrappedCppType, Member<CppType>>::value ||
+      std::is_same<MaybeMemberCppType, Member<CppType>>::value ||
           std::is_class<typename V8TypeOf<CppType>::Type>::value,
-      HeapVector<MaybeWrappedCppType>,
+      HeapVector<MaybeMemberCppType>,
       Vector<CppType>>::type;
 };
 
+// Record
+template <typename Key, typename Value>
+struct IDLRecord final : public IDLBase {
+  static_assert(std::is_same<Key, IDLByteString>::value ||
+                    std::is_same<Key, IDLString>::value ||
+                    std::is_same<Key, IDLUSVString>::value,
+                "IDLRecord keys must be of a WebIDL string type");
+
+ private:
+  // Record keys are always strings, so we do not need to introspect them.
+  using ValueCppType = typename NativeValueTraits<Value>::ImplType;
+  using MaybeMemberValueCppType = typename std::conditional<
+      WTF::IsGarbageCollectedType<ValueCppType>::value,
+      Member<ValueCppType>,
+      ValueCppType>::type;
+
+ public:
+  // Two kinds of types need HeapVector:
+  // 1. Oilpan types, which are wrapped by Member<>.
+  // 2. IDL unions and dictionaries, which are not Oilpan types themselves (and
+  //    are thus not wrapped by Member<>) but have a trace() method and can
+  //    contain Oilpan members. They both also happen to specialize V8TypeOf,
+  //    which we use to recognize them.
+  using ImplType = typename std::conditional<
+      std::is_same<MaybeMemberValueCppType, Member<ValueCppType>>::value ||
+          std::is_class<typename V8TypeOf<ValueCppType>::Type>::value,
+      HeapVector<std::pair<String, MaybeMemberValueCppType>>,
+      Vector<std::pair<String, ValueCppType>>>::type;
+};
+
 }  // namespace blink
 
 #endif  // IDLTypes_h