bind-gen: Implement NativeValueTraits<IDL callback function/interface>

Bug: 839389
Change-Id: I9b6249cc25cf1e2895f4064d0c17e95fa196760f
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2057163
Commit-Queue: Yuki Shiino <yukishiino@chromium.org>
Reviewed-by: Hitoshi Yoshida <peria@chromium.org>
Cr-Commit-Position: refs/heads/master@{#741770}

third_party/blink/renderer/bindings/core/v8/idl_types.h

@@ -193,12 +193,12 @@ struct IDLRecord final : public IDLBase {
 };
 
 // Nullable types
-template <typename InnerType>
+template <typename T>
 struct IDLNullable final : public IDLBase {
   using ImplType = std::conditional_t<
-      NativeValueTraits<InnerType>::has_null_value,
-      typename NativeValueTraits<InnerType>::ImplType,
-      base::Optional<typename NativeValueTraits<InnerType>::ImplType>>;
+      NativeValueTraits<T>::has_null_value,
+      typename NativeValueTraits<T>::ImplType,
+      base::Optional<typename NativeValueTraits<T>::ImplType>>;
 };
 
 // Date

third_party/blink/renderer/bindings/core/v8/native_value_traits_impl.h

@@ -20,7 +20,9 @@
 namespace blink {
 
 class CallbackFunctionBase;
+class CallbackInterfaceBase;
 class EventListener;
+class FlexibleArrayBufferView;
 class ScriptWrappable;
 struct WrapperTypeInfo;
 
@@ -832,13 +834,107 @@ struct NativeValueTraits<
   static T* NativeValue(v8::Isolate* isolate,
                         v8::Local<v8::Value> value,
                         ExceptionState& exception_state) {
-    // Not implemented because of no use case so far.
-    CHECK(false)
-        // Emit a message so that NativeValueTraitsImplTest.IDLCallbackFunction
-        // test can confirm that it's hitting this specific failure. i.e.
-        // the template resolution is working as expected.
-        << "NativeValueTraits<CallbackFunctionBase>::NativeValue "
-        << "is not yet implemented.";
+    if (value->IsFunction())
+      return T::Create(value.As<v8::Function>());
+    exception_state.ThrowTypeError("The given value is not a function.");
+    return nullptr;
+  }
+
+  static T* ArgumentValue(v8::Isolate* isolate,
+                          int argument_index,
+                          v8::Local<v8::Value> value,
+                          ExceptionState& exception_state) {
+    if (value->IsFunction())
+      return T::Create(value.As<v8::Function>());
+    exception_state.ThrowTypeError(
+        ExceptionMessages::ArgumentNotOfType(argument_index, "Function"));
+    return nullptr;
+  }
+};
+
+template <typename T>
+struct NativeValueTraits<
+    IDLNullable<T>,
+    typename std::enable_if_t<std::is_base_of<CallbackFunctionBase, T>::value>>
+    : public NativeValueTraitsBase<IDLNullable<T>> {
+  static T* NativeValue(v8::Isolate* isolate,
+                        v8::Local<v8::Value> value,
+                        ExceptionState& exception_state) {
+    if (value->IsFunction())
+      return T::Create(value.As<v8::Function>());
+    if (value->IsNullOrUndefined())
+      return nullptr;
+    exception_state.ThrowTypeError("The given value is not a function.");
+    return nullptr;
+  }
+
+  static T* ArgumentValue(v8::Isolate* isolate,
+                          int argument_index,
+                          v8::Local<v8::Value> value,
+                          ExceptionState& exception_state) {
+    if (value->IsFunction())
+      return T::Create(value.As<v8::Function>());
+    if (value->IsNullOrUndefined())
+      return nullptr;
+    exception_state.ThrowTypeError(
+        ExceptionMessages::ArgumentNotOfType(argument_index, "Function"));
+    return nullptr;
+  }
+};
+
+// Callback interface types
+template <typename T>
+struct NativeValueTraits<
+    T,
+    typename std::enable_if_t<std::is_base_of<CallbackInterfaceBase, T>::value>>
+    : public NativeValueTraitsBase<T*> {
+  static T* NativeValue(v8::Isolate* isolate,
+                        v8::Local<v8::Value> value,
+                        ExceptionState& exception_state) {
+    if (value->IsObject())
+      return T::Create(value.As<v8::Object>());
+    exception_state.ThrowTypeError("The given value is not an object.");
+    return nullptr;
+  }
+
+  static T* ArgumentValue(v8::Isolate* isolate,
+                          int argument_index,
+                          v8::Local<v8::Value> value,
+                          ExceptionState& exception_state) {
+    if (value->IsObject())
+      return T::Create(value.As<v8::Object>());
+    exception_state.ThrowTypeError(
+        ExceptionMessages::ArgumentNotOfType(argument_index, "Object"));
+    return nullptr;
+  }
+};
+
+template <typename T>
+struct NativeValueTraits<
+    IDLNullable<T>,
+    typename std::enable_if_t<std::is_base_of<CallbackInterfaceBase, T>::value>>
+    : public NativeValueTraitsBase<IDLNullable<T>> {
+  static T* NativeValue(v8::Isolate* isolate,
+                        v8::Local<v8::Value> value,
+                        ExceptionState& exception_state) {
+    if (value->IsObject())
+      return T::Create(value.As<v8::Object>());
+    if (value->IsNullOrUndefined())
+      return nullptr;
+    exception_state.ThrowTypeError("The given value is not an object.");
+    return nullptr;
+  }
+
+  static T* ArgumentValue(v8::Isolate* isolate,
+                          int argument_index,
+                          v8::Local<v8::Value> value,
+                          ExceptionState& exception_state) {
+    if (value->IsObject())
+      return T::Create(value.As<v8::Object>());
+    if (value->IsNullOrUndefined())
+      return nullptr;
+    exception_state.ThrowTypeError(
+        ExceptionMessages::ArgumentNotOfType(argument_index, "Object"));
     return nullptr;
   }
 };

third_party/blink/renderer/bindings/core/v8/native_value_traits_impl_test.cc

@@ -46,17 +46,6 @@ TEST(NativeValueTraitsImplTest, IDLInterface) {
   EXPECT_EQ(nullptr, internals);
 }
 
-TEST(NativeValueTraitsImplTest, IDLCallbackFunction) {
-  V8TestingScope scope;
-  DummyExceptionStateForTesting exception_state;
-  v8::Local<v8::Function> function =
-      v8::Function::New(scope.GetContext(), nullptr).ToLocalChecked();
-  ASSERT_DEATH_IF_SUPPORTED(
-      NativeValueTraits<V8TestSequenceCallback>::NativeValue(
-          scope.GetIsolate(), function, exception_state),
-      "");
-}
-
 TEST(NativeValueTraitsImplTest, IDLRecord) {
   V8TestingScope scope;
   {

third_party/blink/renderer/bindings/core/v8/v8_set_return_value_for_core.h

@@ -6,6 +6,7 @@
 #define THIRD_PARTY_BLINK_RENDERER_BINDINGS_CORE_V8_V8_SET_RETURN_VALUE_FOR_CORE_H_
 
 #include "third_party/blink/renderer/bindings/core/v8/js_event_handler.h"
+#include "third_party/blink/renderer/bindings/core/v8/native_value_traits_impl.h"
 #include "third_party/blink/renderer/platform/bindings/v8_set_return_value.h"
 
 namespace blink {