feat: add property event listener for window and body element.

andycall · andycall · commit 5c9554c1682e · 2022-08-15T23:48:51.000+08:00
diff --git a/bridge/CMakeLists.txt b/bridge/CMakeLists.txt
@@ -277,6 +277,7 @@ if ($ENV{WEBF_JS_ENGINE} MATCHES "quickjs")
     core/frame/legacy/location.cc
     core/frame/legacy/location.h
     core/frame/module_callback_coordinator.h
+    core/frame/window_event_handlers.h
     core/css/legacy/css_style_declaration.cc
     core/css/legacy/css_style_declaration.h
     core/dom/frame_request_callback_collection.cc
diff --git a/bridge/core/dom/document.cc b/bridge/core/dom/document.cc
@@ -4,7 +4,11 @@
  */
 #include "document.h"
 #include "bindings/qjs/exception_message.h"
+#include "core/frame/window.h"
 #include "core/dom/element.h"
+#include "core/dom/comment.h"
+#include "core/dom/document_fragment.h"
+#include "core/dom/text.h"
 #include "core/html/html_body_element.h"
 #include "core/html/html_element.h"
 #include "core/html/html_head_element.h"
@@ -130,6 +134,10 @@ Node* Document::Clone(Document&, CloneChildrenFlag) const {
   return nullptr;
 }
 
+HTMLHtmlElement* Document::documentElement() const {
+  return DynamicTo<HTMLHtmlElement>(document_element_.Get());
+}
+
 void Document::InitDocumentElement() {
   ExceptionState exception_state;
   AppendChild(document_element_, exception_state);
@@ -202,6 +210,18 @@ void Document::CancelAnimationFrame(uint32_t request_id, ExceptionState& excepti
   script_animation_controller_.CancelFrameCallback(GetExecutingContext(), request_id, exception_state);
 }
 
+void Document::SetWindowAttributeEventListener(const AtomicString& event_type, const std::shared_ptr<EventListener>& listener, ExceptionState& exception_state) {
+  Window* window = GetExecutingContext()->window();
+  if (!window) return;
+  window->SetAttributeEventListener(event_type, listener, exception_state);
+}
+
+std::shared_ptr<EventListener> Document::GetWindowAttributeEventListener(const AtomicString& event_type) {
+  Window* window = GetExecutingContext()->window();
+  if (!window) return nullptr;
+  return window->GetAttributeEventListener(event_type);
+}
+
 void Document::Trace(GCVisitor* visitor) const {
   visitor->Trace(document_element_);
   script_animation_controller_.Trace(visitor);
diff --git a/bridge/core/dom/document.h b/bridge/core/dom/document.h
@@ -7,10 +7,6 @@
 
 #include "bindings/qjs/cppgc/local_handle.h"
 #include "container_node.h"
-#include "core/dom/comment.h"
-#include "core/dom/document_fragment.h"
-#include "core/dom/text.h"
-#include "html_element_type_helper.h"
 #include "scripted_animation_controller.h"
 #include "tree_scope.h"
 
@@ -19,6 +15,8 @@ namespace webf {
 class HTMLBodyElement;
 class HTMLHeadElement;
 class HTMLHtmlElement;
+class Text;
+class Comment;
 
 // A document (https://dom.spec.whatwg.org/#concept-document) is the root node
 // of a tree of DOM nodes, generally resulting from the parsing of a markup
@@ -48,7 +46,7 @@ class Document : public ContainerNode, public TreeScope {
 
   Node* Clone(Document&, CloneChildrenFlag) const override;
 
-  [[nodiscard]] HTMLHtmlElement* documentElement() const { return DynamicTo<HTMLHtmlElement>(document_element_.Get()); }
+  [[nodiscard]] HTMLHtmlElement* documentElement() const;
   void InitDocumentElement();
 
   // "body element" as defined by HTML5
@@ -71,6 +69,11 @@ class Document : public ContainerNode, public TreeScope {
   uint32_t RequestAnimationFrame(const std::shared_ptr<FrameCallback>& callback, ExceptionState& exception_state);
   void CancelAnimationFrame(uint32_t request_id, ExceptionState& exception_state);
 
+  // Helper functions for forwarding LocalDOMWindow event related tasks to the
+  // LocalDOMWindow if it exists.
+  void SetWindowAttributeEventListener(const AtomicString& event_type, const std::shared_ptr<EventListener>& listener, ExceptionState& exception_state);
+  std::shared_ptr<EventListener> GetWindowAttributeEventListener(const AtomicString& event_type);
+
   void Trace(GCVisitor* visitor) const override;
 
  private:
diff --git a/bridge/core/dom/element.cc b/bridge/core/dom/element.cc
@@ -3,12 +3,14 @@
  * Copyright (C) 2022-present The WebF authors. All rights reserved.
  */
 #include "element.h"
+#include "text.h"
 
 #include <utility>
 #include "binding_call_methods.h"
 #include "bindings/qjs/exception_state.h"
 #include "bindings/qjs/script_promise.h"
 #include "bindings/qjs/script_promise_resolver.h"
+#include "html_element_type_helper.h"
 #include "core/dom/document_fragment.h"
 #include "core/fileapi/blob.h"
 #include "core/html/html_template_element.h"
diff --git a/bridge/core/dom/events/event_target.cc b/bridge/core/dom/events/event_target.cc
@@ -45,6 +45,10 @@ EventTarget::~EventTarget() {
 EventTarget::EventTarget(ExecutingContext* context)
     : BindingObject(context), ScriptWrappable(context->ctx()), event_target_id_(global_event_target_id++) {}
 
+Node* EventTarget::ToNode() {
+  return nullptr;
+}
+
 bool EventTarget::addEventListener(const AtomicString& event_type,
                                    const std::shared_ptr<EventListener>& event_listener,
                                    const std::shared_ptr<AddEventListenerOptions>& options,
diff --git a/bridge/core/dom/events/event_target.h b/bridge/core/dom/events/event_target.h
@@ -72,6 +72,8 @@ class EventTargetData final {
   std::unique_ptr<FiringEventIteratorVector> firing_event_iterators;
 };
 
+class Node;
+
 // All DOM event targets extend EventTarget. The spec is defined here:
 // https://dom.spec.whatwg.org/#interface-eventtarget
 // EventTarget objects allow us to add and remove an event
@@ -89,6 +91,8 @@ class EventTarget : public ScriptWrappable, public BindingObject {
   ~EventTarget();
   explicit EventTarget(ExecutingContext* context);
 
+  virtual Node* ToNode();
+
   bool addEventListener(const AtomicString& event_type,
                         const std::shared_ptr<EventListener>& event_listener,
                         const std::shared_ptr<AddEventListenerOptions>& options,
@@ -183,29 +187,28 @@ class EventTargetWithInlineData : public EventTarget {
     eventTarget.SetAttributeEventListener(event_type_names::symbol_name, listener, exception_state);      \
   }
 
-#define DEFINE_WINDOW_ATTRIBUTE_EVENT_LISTENER(lower_name, symbol_name)                     \
-  EventListener* on##lower_name() {                                                         \
-    return GetDocument().GetWindowAttributeEventListener(event_type_names::symbol_name);    \
-  }                                                                                         \
-  void setOn##lower_name(EventListener* listener) {                                         \
-    GetDocument().SetWindowAttributeEventListener(event_type_names::symbol_name, listener); \
+#define DEFINE_WINDOW_ATTRIBUTE_EVENT_LISTENER(lower_name, symbol_name)                                      \
+  std::shared_ptr<EventListener> on##lower_name() {                                                          \
+    return GetDocument().GetWindowAttributeEventListener(event_type_names::symbol_name);                     \
+  }                                                                                                          \
+  void setOn##lower_name(const std::shared_ptr<EventListener>& listener, ExceptionState& exception_state) {  \
+    GetDocument().SetWindowAttributeEventListener(event_type_names::symbol_name, listener, exception_state); \
   }
 
-#define DEFINE_STATIC_WINDOW_ATTRIBUTE_EVENT_LISTENER(lower_name, symbol_name)                      \
-  static EventListener* on##lower_name(EventTarget& eventTarget) {                                  \
-    if (Node* node = eventTarget.ToNode()) {                                                        \
-      return node->GetDocument().GetWindowAttributeEventListener(event_type_names::symbol_name);    \
-    }                                                                                               \
-    DCHECK(eventTarget.ToLocalDOMWindow());                                                         \
-    return eventTarget.GetAttributeEventListener(event_type_names::symbol_name);                    \
-  }                                                                                                 \
-  static void setOn##lower_name(EventTarget& eventTarget, EventListener* listener) {                \
-    if (Node* node = eventTarget.ToNode()) {                                                        \
-      node->GetDocument().SetWindowAttributeEventListener(event_type_names::symbol_name, listener); \
-    } else {                                                                                        \
-      DCHECK(eventTarget.ToLocalDOMWindow());                                                       \
-      eventTarget.SetAttributeEventListener(event_type_names::symbol_name, listener);               \
-    }                                                                                               \
+#define DEFINE_STATIC_WINDOW_ATTRIBUTE_EVENT_LISTENER(lower_name, symbol_name)                                       \
+  static std::shared_ptr<EventListener> on##lower_name(EventTarget& eventTarget) {                                   \
+    if (Node* node = eventTarget.ToNode()) {                                                                         \
+      return node->GetDocument().GetWindowAttributeEventListener(event_type_names::symbol_name);                     \
+    }                                                                                                                \
+    return eventTarget.GetAttributeEventListener(event_type_names::symbol_name);                                     \
+  }                                                                                                                  \
+  static void setOn##lower_name(EventTarget& eventTarget, const std::shared_ptr<EventListener>& listener,            \
+                                ExceptionState& exception_state) {                                                   \
+    if (Node* node = eventTarget.ToNode()) {                                                                         \
+      node->GetDocument().SetWindowAttributeEventListener(event_type_names::symbol_name, listener, exception_state); \
+    } else {                                                                                                         \
+      eventTarget.SetAttributeEventListener(event_type_names::symbol_name, listener, exception_state);               \
+    }                                                                                                                \
   }
 
 //
diff --git a/bridge/core/dom/global_event_handlers.d.ts b/bridge/core/dom/global_event_handlers.d.ts
@@ -1,5 +1,7 @@
 type IDLEventHandler = Function;
 
+// @ts-ignore
+@Mixin()
 export interface GlobalEventHandlers {
     /**
      * Fires when the user aborts the download.
diff --git a/bridge/core/dom/node.cc b/bridge/core/dom/node.cc
@@ -7,6 +7,7 @@
 #include <unordered_map>
 #include "character_data.h"
 #include "child_node_list.h"
+#include "element.h"
 #include "document.h"
 #include "document_fragment.h"
 #include "empty_node_list.h"
@@ -21,6 +22,10 @@ Node* Node::Create(ExecutingContext* context, ExceptionState& exception_state) {
   return nullptr;
 }
 
+Node* Node::ToNode() {
+  return this;
+}
+
 void Node::setNodeValue(const AtomicString& value, ExceptionState& exception_state) {
   // By default, setting nodeValue has no effect.
 }
diff --git a/bridge/core/dom/node.h b/bridge/core/dom/node.h
@@ -60,6 +60,8 @@ class Node : public EventTarget {
   using ImplType = Node*;
   static Node* Create(ExecutingContext* context, ExceptionState& exception_state);
 
+  Node* ToNode() override;
+
   // DOM methods & attributes for Node
   virtual std::string nodeName() const = 0;
   virtual std::string nodeValue() const = 0;
diff --git a/bridge/core/executing_context.cc b/bridge/core/executing_context.cc
@@ -266,8 +266,7 @@ static void DispatchPromiseRejectionEvent(const AtomicString& event_type,
   event_init->setReason(Converter<IDLAny>::FromValue(context->ctx(), error, exception_state));
   auto event = PromiseRejectionEvent::Create(context, event_type, event_init, exception_state);
 
-  auto* window = toScriptWrappable<Window>(context->Global());
-  window->dispatchEvent(event, exception_state);
+  context->window()->dispatchEvent(event, exception_state);
   if (exception_state.HasException()) {
     context->ReportError(error);
   }
@@ -289,9 +288,8 @@ void ExecutingContext::DispatchErrorEvent(ErrorEvent* error_event) {
 void ExecutingContext::DispatchErrorEventInterval(ErrorEvent* error_event) {
   assert(!in_dispatch_error_event_);
   in_dispatch_error_event_ = true;
-  auto* window = toScriptWrappable<Window>(Global());
   ExceptionState exception_state;
-  window->dispatchEvent(error_event, exception_state);
+  window_->dispatchEvent(error_event, exception_state);
   in_dispatch_error_event_ = false;
 
   if (exception_state.HasException()) {
@@ -373,9 +371,9 @@ void ExecutingContext::InstallDocument() {
 
 void ExecutingContext::InstallGlobal() {
   MemberMutationScope mutation_scope{this};
-  auto* window = MakeGarbageCollected<Window>(this);
-  JS_SetPrototype(ctx(), Global(), window->ToQuickJSUnsafe());
-  JS_SetOpaque(Global(), window);
+  window_  = MakeGarbageCollected<Window>(this);
+  JS_SetPrototype(ctx(), Global(), window_->ToQuickJSUnsafe());
+  JS_SetOpaque(Global(), window_);
 }
 
 // An lock free context validator.
diff --git a/bridge/core/executing_context.h b/bridge/core/executing_context.h
@@ -38,6 +38,7 @@ struct NativeByteCode {
 
 class ExecutingContext;
 class Document;
+class Window;
 class MemberMutationScope;
 class ErrorEvent;
 
@@ -100,6 +101,7 @@ class ExecutingContext {
   void ClearMutationScope();
 
   FORCE_INLINE Document* document() { return document_; };
+  FORCE_INLINE Window* window() { return window_; }
   FORCE_INLINE UICommandBuffer* uiCommandBuffer() { return &ui_command_buffer_; };
   FORCE_INLINE std::unique_ptr<DartMethodPointer>& dartMethodPtr() { return dart_method_ptr_; }
 
@@ -142,6 +144,7 @@ class ExecutingContext {
   JSValue global_object_{JS_NULL};
   bool ctx_invalid_{false};
   Document* document_{nullptr};
+  Window* window_{nullptr};
   DOMTimerCoordinator timers_;
   ModuleListenerContainer module_listener_container_;
   ModuleCallbackCoordinator module_callbacks_;
diff --git a/bridge/core/executing_context_test.cc b/bridge/core/executing_context_test.cc
@@ -105,8 +105,7 @@ TEST(Context, unrejectPromiseWillTriggerUnhandledRejectionEvent) {
   };
   auto bridge = TEST_init(errorHandler);
   static int logIndex = 0;
-  static std::string logs[] = {"error event cannot read property 'forceNullError' of null",
-                               "unhandled event {promise: Promise {...}, reason: Error {...}} true"};
+  static std::string logs[] = {"unhandled event {promise: Promise {...}, reason: Error {...}} true"};
   webf::WebFPage::consoleMessageHandler = [](void* ctx, const std::string& message, int logLevel) {
     logCalled = true;
     EXPECT_STREQ(logs[logIndex++].c_str(), message.c_str());
@@ -130,7 +129,7 @@ var p = new Promise(function (resolve, reject) {
   bridge->evaluateScript(code.c_str(), code.size(), "file://", 0);
   EXPECT_EQ(errorHandlerExecuted, true);
   EXPECT_EQ(logCalled, true);
-  EXPECT_EQ(logIndex, 2);
+  EXPECT_EQ(logIndex, 1);
   webf::WebFPage::consoleMessageHandler = nullptr;
 }
 
diff --git a/bridge/core/frame/window.d.ts b/bridge/core/frame/window.d.ts
@@ -2,8 +2,9 @@ import {EventTarget} from "../dom/events/event_target";
 import {ScrollOptions} from "../dom/scroll_options";
 import {ScrollToOptions} from "../dom/scroll_to_options";
 import {Screen} from "./screen";
+import {WindowEventHandlers} from "./window_event_handlers";
 
-interface Window extends EventTarget {
+interface Window extends EventTarget, WindowEventHandlers {
   open(url?: string): Window | null;
   scrollTo(options?: ScrollToOptions): void;
   scrollTo(x: number, y: number): void;
diff --git a/bridge/core/frame/window_event_handlers.d.ts b/bridge/core/frame/window_event_handlers.d.ts
@@ -0,0 +1,14 @@
+type IDLEventHandler = Function;
+
+export interface WindowEventHandlers {
+    onbeforeunload: IDLEventHandler | null;
+    onhashchange: IDLEventHandler | null;
+    onmessage: IDLEventHandler | null;
+    onmessageerror: IDLEventHandler | null;
+    onpagehide: IDLEventHandler | null;
+    onpageshow: IDLEventHandler | null;
+    onpopstate: IDLEventHandler | null;
+    onrejectionhandled: IDLEventHandler | null;
+    onunhandledrejection: IDLEventHandler | null;
+    onunload: IDLEventHandler | null;
+}
diff --git a/bridge/core/frame/window_event_handlers.h b/bridge/core/frame/window_event_handlers.h
@@ -0,0 +1,33 @@
+/*
+* Copyright (C) 2022-present The WebF authors. All rights reserved.
+*/
+
+#ifndef BRIDGE_CORE_FRAME_WINDOW_EVENT_HANDLERS_H_
+#define BRIDGE_CORE_FRAME_WINDOW_EVENT_HANDLERS_H_
+
+#include "foundation/macros.h"
+#include "event_type_names.h"
+#include "core/dom/document.h"
+
+namespace webf {
+
+class WindowEventHandlers {
+  WEBF_STATIC_ONLY(WindowEventHandlers);
+
+ public:
+  DEFINE_STATIC_WINDOW_ATTRIBUTE_EVENT_LISTENER(beforeunload, kbeforeunload);
+  DEFINE_STATIC_WINDOW_ATTRIBUTE_EVENT_LISTENER(hashchange, khashchange);
+  DEFINE_STATIC_WINDOW_ATTRIBUTE_EVENT_LISTENER(message, kmessage);
+  DEFINE_STATIC_WINDOW_ATTRIBUTE_EVENT_LISTENER(messageerror, kmessageerror);
+  DEFINE_STATIC_WINDOW_ATTRIBUTE_EVENT_LISTENER(pagehide, kpagehide);
+  DEFINE_STATIC_WINDOW_ATTRIBUTE_EVENT_LISTENER(pageshow, kpageshow);
+  DEFINE_STATIC_WINDOW_ATTRIBUTE_EVENT_LISTENER(popstate, kpopstate);
+  DEFINE_STATIC_WINDOW_ATTRIBUTE_EVENT_LISTENER(rejectionhandled, krejectionhandled);
+  DEFINE_STATIC_WINDOW_ATTRIBUTE_EVENT_LISTENER(unhandledrejection, kunhandledrejection);
+  DEFINE_STATIC_WINDOW_ATTRIBUTE_EVENT_LISTENER(unload, kunload);
+};
+
+}
+
+
+#endif  // BRIDGE_CORE_FRAME_WINDOW_EVENT_HANDLERS_H_
diff --git a/bridge/core/html/html_body_element.d.ts b/bridge/core/html/html_body_element.d.ts
@@ -1,5 +1,13 @@
 import {HTMLElement} from "./html_element";
+import {IDLEventHandler, WindowEventHandlers} from "../frame/window_event_handlers";
+
+export interface HTMLBodyElement extends HTMLElement, WindowEventHandlers {
+  onblur: IDLEventHandler | null;
+  onerror: IDLEventHandler | null;
+  onfocus: IDLEventHandler | null;
+  onload: IDLEventHandler | null;
+  onresize: IDLEventHandler | null;
+  onscroll: IDLEventHandler | null;
 
-export interface HTMLBodyElement extends HTMLElement {
   new(): void;
 }
diff --git a/bridge/core/html/html_body_element.h b/bridge/core/html/html_body_element.h
@@ -6,6 +6,8 @@
 #define BRIDGE_CORE_HTML_HTML_BODY_ELEMENT_H_
 
 #include "html_element.h"
+#include "core/dom/document.h"
+#include "core/frame/window_event_handlers.h"
 
 namespace webf {
 
@@ -15,6 +17,14 @@ class HTMLBodyElement : public HTMLElement {
  public:
   using ImplType = HTMLBodyElement*;
   explicit HTMLBodyElement(Document&);
+
+  DEFINE_WINDOW_ATTRIBUTE_EVENT_LISTENER(blur, kblur);
+  DEFINE_WINDOW_ATTRIBUTE_EVENT_LISTENER(error, kerror);
+  DEFINE_WINDOW_ATTRIBUTE_EVENT_LISTENER(focus, kfocus);
+  DEFINE_WINDOW_ATTRIBUTE_EVENT_LISTENER(load, kload);
+  DEFINE_WINDOW_ATTRIBUTE_EVENT_LISTENER(resize, kresize);
+  DEFINE_WINDOW_ATTRIBUTE_EVENT_LISTENER(scroll, kscroll);
+  DEFINE_WINDOW_ATTRIBUTE_EVENT_LISTENER(orientationchange, korientationchange);
 };
 
 }  // namespace webf
diff --git a/bridge/core/html/parser/html_parser.cc b/bridge/core/html/parser/html_parser.cc
diff --git a/bridge/core/page.cc b/bridge/core/page.cc
diff --git a/bridge/scripts/code_generator/src/idl/analyzer.ts b/bridge/scripts/code_generator/src/idl/analyzer.ts
diff --git a/bridge/scripts/code_generator/src/idl/generateHeader.ts b/bridge/scripts/code_generator/src/idl/generateHeader.ts
diff --git a/bridge/scripts/code_generator/static/idl_templates/base.cc.tpl b/bridge/scripts/code_generator/static/idl_templates/base.cc.tpl
diff --git a/bridge/test/webf_test_context.cc b/bridge/test/webf_test_context.cc
