Add toImplSequence()

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 710 matching lines @@
         result.reserveInitialCapacity(length - startIndex);
         for (int i = startIndex; i < length; ++i) {
             result.uncheckedAppend(TraitsType::nativeValue(info.GetIsolate(), info[i], exceptionState));
             if (exceptionState.hadException())
                 return VectorType();
         }
     }
     return result;
 }
 
+// Gets an iterator from an Object.
+v8::MaybeLocal<v8::Object> getIterator(v8::Local<v8::Object>, v8::Isolate*, ExceptionState&);

[haraken, 2016/09/08 09:32:08]

I don't have any strong opinion but might prefer returning
v8::Local<v8::Object>. i.e., return an empty handle when the iterator is not
available.

[bashi, 2016/09/09 00:54:22]

I think using MaybeLocal has two advantages:
1. Caller must check empty handles
2.
  - !MaybeLocal.ToLocal() -> We are sure that there is an exception.
  - Local.IsEmpty() -> No information.

MaybeLocal is useful in some cases. We shouldn't avoid using it too much.

+
+// Converts a V8 value to an array (an IDL sequence) as per the WebIDL
+// specification: http://heycam.github.io/webidl/#es-sequence
+template <typename VectorType>
+VectorType toImplSequence(v8::Local<v8::Value> value, v8::Isolate* isolate, ExceptionState& exceptionState)

[Yuki, 2016/09/08 08:32:21]

Could you make v8::Isolate* the first argument?

[bashi, 2016/09/09 00:54:23]

Done. Having said that it's inconsistent with other array or sequence conversion
functions like toImplArray(). I'm not sure putting isolate first makes sense at
this point. (I don't want to change other signatures in this CL)

+{
+    typedef typename VectorType::ValueType ValueType;

[Yuki, 2016/09/08 08:32:21]

I guess
    using VectorType::ValueType;
does the trick.

[bashi, 2016/09/09 00:54:22]

Done.

+
+    if (!value->IsObject() || value->IsRegExp()) {
+        exceptionState.throwTypeError("The provided value cannot be converted to a sequence.");
+        return VectorType();
+    }
+
+    v8::Local<v8::Object> iterator;
+    if (!getIterator(value.As<v8::Object>(), isolate, exceptionState).ToLocal(&iterator))
+        return VectorType();
+
+    v8::Local<v8::String> nextKey = v8String(isolate, "next");
+    v8::Local<v8::String> valueKey = v8String(isolate, "value");
+    v8::Local<v8::String> doneKey = v8String(isolate, "done");
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
+    VectorType result;
+    while (true) {
+        v8::Local<v8::Value> next;
+        if (!iterator->Get(context, nextKey).ToLocal(&next))
+            return VectorType();
+        if (!next->IsObject() || !next.As<v8::Object>()->IsCallable()) {
+            exceptionState.throwTypeError("The next property should be callable.");

[Yuki, 2016/09/08 08:32:21]

I think
  "Iterator.next should be callable."
is easier to understand, like below.

[bashi, 2016/09/09 00:54:23]

Done.

+            return VectorType();
+        }
+        v8::Local<v8::Value> nextResult;
+        if (!next.As<v8::Object>()->CallAsFunction(context, iterator, 0, nullptr).ToLocal(&nextResult))
+            return VectorType();

[haraken, 2016/09/08 09:32:08]

Don't we need to throw an exception?

[bashi, 2016/09/09 00:54:23]

No, as described in another reply.

+        if (!nextResult->IsObject()) {
+            exceptionState.throwTypeError("Iterator.next() does not return an object.");

[Yuki, 2016/09/08 08:32:21]

s/does/did/

[bashi, 2016/09/09 00:54:23]

Done.

+            return VectorType();
+        }
+        v8::Local<v8::Object> resultObject = nextResult.As<v8::Object>();
+        v8::Local<v8::Value> element;
+        v8::Local<v8::Value> done;
+        if (!resultObject->Get(context, valueKey).ToLocal(&element)
+            || !resultObject->Get(context, doneKey).ToLocal(&done))
+            return VectorType();

[haraken, 2016/09/08 09:32:08]

Ditto.

+        v8::Local<v8::Boolean> doneBoolean;
+        if (!done->ToBoolean(context).ToLocal(&doneBoolean))
+            return VectorType();

[haraken, 2016/09/08 09:32:08]

Ditto.

+        result.uncheckedAppend(NativeValueTraits<ValueType>::nativeValue(isolate, element, exceptionState));
+        if (doneBoolean->Value())
+            break;
+    }
+    return result;
+}
+
 // Validates that the passed object is a sequence type per WebIDL spec
 // http://www.w3.org/TR/2012/CR-WebIDL-20120419/#es-sequence
 inline bool toV8Sequence(v8::Local<v8::Value> value, uint32_t& length, v8::Isolate* isolate, ExceptionState& exceptionState)
 {
     // Attempt converting to a sequence if the value is not already an array but is
     // any kind of object except for a native Date object or a native RegExp object.
     ASSERT(!value->IsArray());
     // FIXME: Do we really need to special case Date and RegExp object?
     // https://www.w3.org/Bugs/Public/show_bug.cgi?id=22806
     if (!value->IsObject() || value->IsDate() || value->IsRegExp()) {
@@ skipping 221 matching lines @@
 typedef void (*InstallTemplateFunction)(v8::Isolate*, const DOMWrapperWorld&, v8::Local<v8::FunctionTemplate> interfaceTemplate);
 
 // Freeze a V8 object. The type of the first parameter and the return value is
 // intentionally v8::Value so that this function can wrap toV8().
 // If the argument isn't an object, this will crash.
 CORE_EXPORT v8::Local<v8::Value> freezeV8Object(v8::Local<v8::Value>, v8::Isolate*);
 
 } // namespace blink
 
 #endif // V8Binding_h