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

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

 /*
 * Copyright (C) 2009 Google Inc. All rights reserved.
 * Copyright (C) 2012 Ericsson AB. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
@@ skipping 743 matching lines @@
     } else {
       exceptionState.throwTypeError("Invalid Array element type");
       return VectorType();
     }
   }
   return result;
 }
 
 // Converts a JavaScript value to an array as per the Web IDL specification:
 // http://www.w3.org/TR/2012/CR-WebIDL-20120419/#es-array
-template <typename VectorType>
+template <typename VectorType,
+          typename ValueType = typename VectorType::ValueType>
 VectorType toImplArray(v8::Local<v8::Value> value,
                        int argumentIndex,
                        v8::Isolate* isolate,
                        ExceptionState& exceptionState) {
-  typedef typename VectorType::ValueType ValueType;
   typedef NativeValueTraits<ValueType> TraitsType;
 
   uint32_t length = 0;
   if (value->IsArray()) {
     length = v8::Local<v8::Array>::Cast(value)->Length();
   } else if (!toV8Sequence(value, length, isolate, exceptionState)) {
     if (!exceptionState.hadException())
       exceptionState.throwTypeError(
           ExceptionMessages::notAnArrayTypeArgumentOrValue(argumentIndex));
     return VectorType();
@@ skipping 116 matching lines @@
   if (!v8Call(lengthValue->Uint32Value(isolate->GetCurrentContext()),
               sequenceLength, block)) {
     exceptionState.rethrowV8Exception(block.Exception());
     return false;
   }
 
   length = sequenceLength;
   return true;
 }
 
+WARN_UNUSED_RESULT CORE_EXPORT v8::MaybeLocal<v8::String> getStringValueInArray(

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

nit: I'm on the fence whether the name of |getStringValueInArray| is too generic
in global namespace or not.

Both of String and Array could be understood as WTF::String or WTF::Vector for
example.  If this is a helper function in local namespace, I'm fine.

+    v8::Local<v8::Context> context,
+    v8::Local<v8::Array> array,
+    uint32_t index);
+
+CORE_EXPORT bool isPropertyEnumerable(v8::Isolate* isolate,
+                          v8::Local<v8::Value> descriptor,
+                          ExceptionState& exceptionState);
+
+// Converts a JavaScript value |O| to an IDL record<K, V> value.
+// In C++, a record is represented as a Vector<std::pair<k, v>> (or a
+// HeapVector if v is a type that uses Oilpain).
+// See https://heycam.github.io/webidl/#es-record.
+template <typename KeyType, typename ValueType, typename VectorType>
+VectorType toImplRecord(v8::Isolate* isolate,
+                        v8::Local<v8::Value> originalValue,
+                        ExceptionState& exceptionState) {
+  // "1. If Type(O) is not Object, throw a TypeError."
+  if (!originalValue->IsObject()) {
+    exceptionState.throwTypeError(
+        "Only objects can be converted to record<K,V> types");
+    return VectorType();
+  }
+  v8::Local<v8::Object> v8Object = v8::Local<v8::Object>::Cast(originalValue);
+  v8::TryCatch block(isolate);
+
+  // "3. Let keys be ? O.[[OwnPropertyKeys]]()."
+  v8::Local<v8::Array> keys;
+  // While we could pass v8::ONLY_ENUMERABLE below, doing so breaks
+  // web-platform-tests' headers-record.html and deviates from the spec
+  // algorithm.
+  // Symbols are being skipped due to
+  // https://github.com/heycam/webidl/issues/294.
+  if (!v8Object
+           ->GetOwnPropertyNames(isolate->GetCurrentContext(),
+                                 static_cast<v8::PropertyFilter>(
+                                     v8::PropertyFilter::ALL_PROPERTIES |
+                                     v8::PropertyFilter::SKIP_SYMBOLS))
+           .ToLocal(&keys)) {
+    exceptionState.rethrowV8Exception(block.Exception());
+    return VectorType();
+  }
+  if (keys->Length() > VectorType::maxCapacity()) {
+    exceptionState.throwRangeError("Array length exceeds supported limit.");
+    return VectorType();
+  }
+
+  // "2. Let result be a new empty instance of record<K, V>."
+  VectorType result;
+  result.reserveInitialCapacity(keys->Length());
+
+  // The conversion algorithm needs a data structure with fast insertion at the
+  // end while at the same time requiring fast checks for previous insert of a
+  // given key. |seenKeys| is a key/position in |result| map that aids in the
+  // latter part.
+  HashMap<String, size_t> seenKeys;
+
+  for (uint32_t i = 0; i < keys->Length(); ++i) {
+    // "4. Repeat, for each element key of keys in List order:"
+    v8::Local<v8::String> key;
+    if (!getStringValueInArray(isolate->GetCurrentContext(), keys, i)
+             .ToLocal(&key)) {
+      exceptionState.rethrowV8Exception(block.Exception());

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

Not directly related to your CL, we may want an utility to do this
automatically.

    v8::TryCatch tryCatch(isolate);
    ExceptionStateRethrowScope rethrowScope(exceptionState, tryCatch);

    if (failure) {
      // rethrowScope's dtor automatically does the job.
      return VectorType();
    }

We're seeing this pattern too often.

+      return VectorType();
+    }
+
+    // "4.1. Let desc be ? O.[[GetOwnProperty]](key)."
+    v8::Local<v8::Value> desc;
+    if (!v8Object->GetOwnPropertyDescriptor(isolate->GetCurrentContext(), key)
+             .ToLocal(&desc)) {
+      exceptionState.rethrowV8Exception(block.Exception());
+      return VectorType();
+    }
+
+    // "4.2. If desc is not undefined and desc.[[Enumerable]] is true:"
+    if (!isPropertyEnumerable(isolate, desc, exceptionState)) {
+      if (exceptionState.hadException())
+        return VectorType();
+      continue;
+    }
+
+    // "4.2.1. Let typedKey be key converted to an IDL value of type K."
+    String typedKey =
+        NativeValueTraits<KeyType>::nativeValue(isolate, key, exceptionState);
+    if (exceptionState.hadException())
+      return VectorType();
+
+    // "4.2.2. Let value be ? Get(O, key)."
+    v8::Local<v8::Value> value;
+    if (!v8Object->Get(isolate->GetCurrentContext(), key).ToLocal(&value)) {
+      exceptionState.rethrowV8Exception(block.Exception());
+      return VectorType();
+    }
+
+    // "4.2.3. Let typedValue be value converted to an IDL value of type V."
+    typename VectorType::ValueType::second_type typedValue =
+        NativeValueTraits<ValueType>::nativeValue(isolate, value,
+                                                  exceptionState);
+    if (exceptionState.hadException())
+      return VectorType();
+
+    if (seenKeys.contains(typedKey)) {
+      // "4.2.4. If typedKey is already a key in result, set its value to
+      //         typedValue.
+      //         Note: This can happen when O is a proxy object."
+      const size_t pos = seenKeys.at(typedKey);
+      result[pos] = std::make_pair(typedKey, typedValue);
+    } else {
+      // "4.2.5. Otherwise, append to result a mapping (typedKey, typedValue)."
+      const size_t pos = result.size();  // We can take this shortcut because
+                                         // we are always appending.
+      seenKeys.set(typedKey, pos);
+      result.uncheckedAppend(std::make_pair(typedKey, typedValue));
+    }
+  }
+  // "5. Return result."
+  return result;
+}
+
 template <>
 struct NativeValueTraits<String> {
   static inline String nativeValue(v8::Isolate* isolate,
                                    v8::Local<v8::Value> value,
                                    ExceptionState& exceptionState) {
     V8StringResource<> stringValue(value);
     if (!stringValue.prepare(exceptionState))
       return String();
     return stringValue;
   }
@@ skipping 244 matching lines @@
 // If the argument isn't an object, this will crash.
 CORE_EXPORT v8::Local<v8::Value> freezeV8Object(v8::Local<v8::Value>,
                                                 v8::Isolate*);
 
 CORE_EXPORT v8::Local<v8::Value> fromJSONString(v8::Isolate*,
                                                 const String& stringifiedJSON,
                                                 ExceptionState&);
 }  // namespace blink
 
 #endif  // V8Binding_h