feat: support generate dictionary type code.

Author: andycall

bridge/CMakeLists.txt

@@ -311,6 +311,10 @@ if ($ENV{KRAKEN_JS_ENGINE} MATCHES "quickjs")
     out/qjs_blob.h
     out/qjs_event.cc
     out/qjs_event.h
+    out/qjs_error_event.h
+    out/qjs_error_event.cc
+    out/qjs_event_init.h
+    out/qjs_event_init.cc
     out/qjs_event_target.cc
     out/qjs_event_target.h
     out/event_type_names.h

bridge/bindings/qjs/atom_string.cc

@@ -7,9 +7,5 @@
 
 namespace kraken {
 
-JSValue StaticAtomicString::ToQuickJS(JSContext* ctx) const {
-  return JS_AtomToValue(ctx, atom_);
-}
-
 
 }  // namespace kraken

bridge/bindings/qjs/atom_string.h

@@ -11,6 +11,7 @@
 #include "foundation/macros.h"
 #include "foundation/native_string.h"
 #include "native_string_utils.h"
+#include "qjs_engine_patch.h"
 
 namespace kraken {
 
@@ -20,77 +21,60 @@ namespace kraken {
 // two String instances because we just check string storage identity.
 class AtomicString {
  public:
+  static AtomicString Empty(JSContext* ctx) { return AtomicString(ctx, JS_ATOM_NULL); };
+  static AtomicString From(JSContext* ctx, NativeString* native_string) {
+    JSValue str = JS_NewUnicodeString(ctx, native_string->string, native_string->length);
+    auto result = AtomicString(ctx, str);
+    JS_FreeValue(ctx, str);
+    return result;
+  };
+
   AtomicString() = default;
-  AtomicString(JSAtom atom) : atom_(atom) {}
+  AtomicString(JSContext *ctx, JSAtom atom) : ctx_(ctx), atom_(atom) {};
+  AtomicString(JSContext* ctx, const std::string& string) : ctx_(ctx), atom_(JS_NewAtom(ctx, string.c_str())) {};
+  AtomicString(JSContext* ctx, JSValue value) : ctx_(ctx), atom_(JS_ValueToAtom(ctx, value)) {};
+  AtomicString(JSAtom atom): atom_(atom), is_static_atom_(true) {};
 
   // Return the undefined string value from atom key.
-  virtual JSValue ToQuickJS(JSContext* ctx) const = 0;
-
-  bool operator==(const AtomicString& other) const { return other.atom_ == this->atom_; }
-
- protected:
-  JSAtom atom_{JS_ATOM_NULL};
-};
-
-// AtomicString which holding quickjs built-in atoms string.
-// These string are stored in JSRuntime instead of JSContext.
-// So it can be used by any JSContext and don't needs to be freed.
-class PersistentAtomicString : public AtomicString {
- public:
-  PersistentAtomicString(JSAtom atom): AtomicString(atom) {};
-
-  JSValue ToQuickJS(JSContext* ctx) const override;
-};
-
-// PeriodicAtomicString holding string atom key created by JSContext.
-// Could be freed when string refer_count set to 0.
-class PeriodicAtomicString : public AtomicString {
-  // Should only allocate on stack.
-  KRAKEN_DISALLOW_NEW();
-
- public:
-  static PeriodicAtomicString Empty(JSContext* ctx) { return PeriodicAtomicString(ctx); };
-
-  explicit PeriodicAtomicString(JSContext* ctx) : ctx_(ctx), AtomicString(JS_ATOM_NULL) {}
-  explicit PeriodicAtomicString(JSContext* ctx, const std::string& string) : ctx_(ctx), AtomicString(JS_NewAtom(ctx, string.c_str())) {}
-  explicit PeriodicAtomicString(JSContext* ctx, JSAtom atom) : ctx_(ctx), AtomicString(JS_DupAtom(ctx, atom)) {};
-  explicit PeriodicAtomicString(JSContext* ctx, JSValue value) : ctx_(ctx), AtomicString(JS_ValueToAtom(ctx, value)){};
-  ~PeriodicAtomicString() { JS_FreeAtom(ctx_, atom_); }
-
-  JSValue ToQuickJS(JSContext* ctx) const { return JS_AtomToValue(ctx, atom_); }
+  JSValue ToQuickJS(JSContext* ctx) const {
+    return JS_AtomToValue(ctx, atom_);
+  };
 
   // Copy assignment
-  PeriodicAtomicString(PeriodicAtomicString const& value) {
-    if (&value != this) {
+  AtomicString(AtomicString const& value) {
+    if (!is_static_atom_ && &value != this) {
       atom_ = JS_DupAtom(ctx_, value.atom_);
     }
     ctx_ = value.ctx_;
   };
-  PeriodicAtomicString& operator=(const PeriodicAtomicString& other) {
-    if (&other != this) {
+  AtomicString& operator=(const AtomicString& other) {
+    if (!is_static_atom_ && &other != this) {
       atom_ = JS_DupAtom(ctx_, other.atom_);
     }
     return *this;
   };
 
   // Move assignment
-  PeriodicAtomicString(PeriodicAtomicString&& value) noexcept {
-    if (&value != this) {
+  AtomicString(AtomicString&& value) noexcept {
+    if (!is_static_atom_ && &value != this) {
       atom_ = JS_DupAtom(ctx_, value.atom_);
     }
     ctx_ = value.ctx_;
   };
-  PeriodicAtomicString& operator=(PeriodicAtomicString&& value) noexcept {
-    if (&value != this) {
+  AtomicString& operator=(AtomicString&& value) noexcept {
+    if (!is_static_atom_ && &value != this) {
       atom_ = JS_DupAtom(ctx_, value.atom_);
     }
     ctx_ = value.ctx_;
     return *this;
   }
 
- private:
-  PeriodicAtomicString() = delete;
+  bool operator==(const AtomicString& other) const { return other.atom_ == this->atom_; }
+
+ protected:
+  bool is_static_atom_ = false;
   JSContext* ctx_{nullptr};
+  JSAtom atom_{JS_ATOM_NULL};
 };
 
 }  // namespace kraken

bridge/bindings/qjs/converter_impl.h

@@ -178,7 +178,7 @@ struct Converter<IDLDOMString> : public ConverterBase<IDLDOMString> {
     return AtomicString(ctx, value);
   }
 
-  static JSValue ToValue(JSContext* ctx, const AtomicString& value) { return value.ToQuickJS(); }
+  static JSValue ToValue(JSContext* ctx, const AtomicString& value) { return value.ToQuickJS(ctx); }
   static JSValue ToValue(JSContext* ctx, NativeString* str) { return JS_NewUnicodeString(ctx, str->string, str->length); }
   static JSValue ToValue(JSContext* ctx, std::unique_ptr<NativeString> str) { return JS_NewUnicodeString(ctx, str->string, str->length); }
   static JSValue ToValue(JSContext* ctx, uint16_t* bytes, size_t length) { return JS_NewUnicodeString(ctx, bytes, length); }
@@ -341,7 +341,7 @@ struct Converter<Event> : public ConverterBase<Event> {
     return toScriptWrappable<Event>(value);
   }
 
-  static JSValue ToValue(JSContext* ctx, ImplType value) { return value->ToQuickJS(); }
+  static JSValue ToValue(JSContext* ctx, ImplType value) { return reinterpret_cast<ScriptWrappable*>(value)->ToQuickJS(); }
 };
 
 }  // namespace kraken

bridge/bindings/qjs/idl_type.h

@@ -50,7 +50,7 @@ class NativeString;
 struct IDLDOMString final : public IDLTypeBaseHelper<AtomicString> {};
 
 // https://developer.mozilla.org/en-US/docs/Web/API/USVString
-struct IDLUSVString final : public IDLTypeBaseHelper<std::string> {};
+struct IDLUSVString final : public IDLTypeBaseHelper<AtomicString> {};
 
 // Object
 struct IDLObject : public IDLTypeBaseHelper<ScriptValue> {};

bridge/bindings/qjs/js_based_event_listener.h

@@ -21,6 +21,14 @@ class JSBasedEventListener : public EventListener {
   // Implements step 2. of "inner invoke".
   // See: https://dom.spec.whatwg.org/#concept-event-listener-inner-invoke
   void Invoke(ExecutingContext* context, Event* event) final;
+
+  // Implements "get the current value of the event handler".
+  // https://html.spec.whatwg.org/C/#getting-the-current-value-of-the-event-handler
+  // Returns v8::Null with firing error event instead of throwing an exception
+  // on failing to compile the uncompiled script body in eventHandler's value.
+  // Also, this can return empty because of crbug.com/881688 .
+  virtual JSValue GetListenerObject(EventTarget&) = 0;
+
   // Returns Functions that handles invoked event or undefined without
   // throwing any exception.
   virtual JSValue GetEffectiveFunction(EventTarget&) = 0;