LibJS+LibWeb: Move native properties to separate getters/setters

This was a bit cumbersome now, but it gets us closer to a format suited
for code generation.

Libraries/LibWeb/Bindings/CanvasRenderingContext2DWrapper.cpp

@@ -43,14 +43,7 @@ CanvasRenderingContext2DWrapper* wrap(JS::Heap& heap, CanvasRenderingContext2D&
 CanvasRenderingContext2DWrapper::CanvasRenderingContext2DWrapper(CanvasRenderingContext2D& impl)
     : m_impl(impl)
 {
-    put_native_property(
-        "fillStyle",
-        [this](JS::Object*) {
-            return JS::js_string(heap(), m_impl->fill_style());
-        },
-        [this](JS::Object*, JS::Value value) {
-            m_impl->set_fill_style(value.to_string());
-        });
+    put_native_property("fillStyle", fill_style_getter, fill_style_setter);
     put_native_function("fillRect", fill_rect);
 }
 
@@ -58,18 +51,39 @@ CanvasRenderingContext2DWrapper::~CanvasRenderingContext2DWrapper()
 {
 }
 
-JS::Value CanvasRenderingContext2DWrapper::fill_rect(JS::Interpreter& interpreter)
+static CanvasRenderingContext2D* impl_from(JS::Interpreter& interpreter)
 {
     auto* this_object = interpreter.this_value().to_object(interpreter.heap());
     if (!this_object)
-        return {};
+        return nullptr;
     // FIXME: Verify that it's a CanvasRenderingContext2DWrapper somehow!
-    auto& impl = static_cast<CanvasRenderingContext2DWrapper*>(this_object)->impl();
+    return &static_cast<CanvasRenderingContext2DWrapper*>(this_object)->impl();
+}
+
+JS::Value CanvasRenderingContext2DWrapper::fill_rect(JS::Interpreter& interpreter)
+{
+    auto* impl = impl_from(interpreter);
+    if (!impl)
+        return {};
     auto& arguments = interpreter.call_frame().arguments;
     if (arguments.size() >= 4)
-        impl.fill_rect(arguments[0].to_i32(), arguments[1].to_i32(), arguments[2].to_i32(), arguments[3].to_i32());
+        impl->fill_rect(arguments[0].to_i32(), arguments[1].to_i32(), arguments[2].to_i32(), arguments[3].to_i32());
     return JS::js_undefined();
 }
 
+JS::Value CanvasRenderingContext2DWrapper::fill_style_getter(JS::Interpreter& interpreter)
+{
+    auto* impl = impl_from(interpreter);
+    if (!impl)
+        return {};
+    return JS::js_string(interpreter.heap(), impl->fill_style());
+}
+
+void CanvasRenderingContext2DWrapper::fill_style_setter(JS::Interpreter& interpreter, JS::Value value)
+{
+    if (auto* impl = impl_from(interpreter))
+        impl->set_fill_style(value.to_string());
+}
+
 }
 }

Libraries/LibWeb/Bindings/CanvasRenderingContext2DWrapper.h

@@ -43,6 +43,8 @@ private:
     virtual const char* class_name() const override { return "CanvasRenderingContext2DWrapper"; }
 
     static JS::Value fill_rect(JS::Interpreter&);
+    static JS::Value fill_style_getter(JS::Interpreter&);
+    static void fill_style_setter(JS::Interpreter&, JS::Value);
 
     NonnullRefPtr<CanvasRenderingContext2D> m_impl;
 };

Libraries/LibWeb/Bindings/ElementWrapper.cpp

@@ -26,6 +26,7 @@
 
 #include <AK/FlyString.h>
 #include <AK/Function.h>
+#include <LibJS/Interpreter.h>
 #include <LibJS/Runtime/PrimitiveString.h>
 #include <LibJS/Runtime/Value.h>
 #include <LibWeb/Bindings/ElementWrapper.h>
@@ -37,14 +38,7 @@ namespace Bindings {
 ElementWrapper::ElementWrapper(Element& element)
     : NodeWrapper(element)
 {
-    put_native_property(
-        "innerHTML",
-        [this](JS::Object*) {
-            return JS::js_string(heap(), node().inner_html());
-        },
-        [this](JS::Object*, JS::Value value) {
-            node().set_inner_html(value.to_string());
-        });
+    put_native_property("innerHTML", inner_html_getter, inner_html_setter);
 }
 
 ElementWrapper::~ElementWrapper()
@@ -61,5 +55,27 @@ const Element& ElementWrapper::node() const
     return static_cast<const Element&>(NodeWrapper::node());
 }
 
+static Element* impl_from(JS::Interpreter& interpreter)
+{
+    auto* this_object = interpreter.this_value().to_object(interpreter.heap());
+    if (!this_object)
+        return nullptr;
+    // FIXME: Verify that it's an ElementWrapper somehow!
+    return &static_cast<ElementWrapper*>(this_object)->node();
+}
+
+JS::Value ElementWrapper::inner_html_getter(JS::Interpreter& interpreter)
+{
+    if (auto* impl = impl_from(interpreter))
+        return JS::js_string(interpreter.heap(), impl->inner_html());
+    return {};
+}
+
+void ElementWrapper::inner_html_setter(JS::Interpreter& interpreter, JS::Value value)
+{
+    if (auto* impl = impl_from(interpreter))
+        impl->set_inner_html(value.to_string());
+}
+
 }
 }

Libraries/LibWeb/Bindings/ElementWrapper.h

@@ -41,6 +41,9 @@ public:
 
 private:
     virtual const char* class_name() const override { return "ElementWrapper"; }
+
+    static JS::Value inner_html_getter(JS::Interpreter&);
+    static void inner_html_setter(JS::Interpreter&, JS::Value);
 };
 
 }

Libraries/LibWeb/Bindings/HTMLCanvasElementWrapper.cpp

@@ -42,18 +42,8 @@ HTMLCanvasElementWrapper::HTMLCanvasElementWrapper(HTMLCanvasElement& element)
 {
     put_native_function("getContext", get_context);
 
-    put_native_property(
-        "width",
-        [this](JS::Object*) {
-            return JS::Value(node().preferred_width());
-        },
-        nullptr);
-    put_native_property(
-        "height",
-        [this](JS::Object*) {
-            return JS::Value(node().preferred_height());
-        },
-        nullptr);
+    put_native_property("width", width_getter, nullptr);
+    put_native_property("height", height_getter, nullptr);
 }
 
 HTMLCanvasElementWrapper::~HTMLCanvasElementWrapper()
@@ -70,20 +60,41 @@ const HTMLCanvasElement& HTMLCanvasElementWrapper::node() const
     return static_cast<const HTMLCanvasElement&>(NodeWrapper::node());
 }
 
-JS::Value HTMLCanvasElementWrapper::get_context(JS::Interpreter& interpreter)
+static HTMLCanvasElement* impl_from(JS::Interpreter& interpreter)
 {
     auto* this_object = interpreter.this_value().to_object(interpreter.heap());
     if (!this_object)
+        return nullptr;
+    // FIXME: Verify that it's a HTMLCanvasElementWrapper somehow!
+    return &static_cast<HTMLCanvasElementWrapper*>(this_object)->node();
+}
+
+JS::Value HTMLCanvasElementWrapper::get_context(JS::Interpreter& interpreter)
+{
+    auto* impl = impl_from(interpreter);
+    if (!impl)
         return {};
-    // FIXME: Verify that it's an HTMLCanvasElementWrapper somehow!
-    auto& node = static_cast<HTMLCanvasElementWrapper*>(this_object)->node();
     auto& arguments = interpreter.call_frame().arguments;
     if (arguments.size() >= 1) {
-        auto* context = node.get_context(arguments[0].to_string());
+        auto* context = impl->get_context(arguments[0].to_string());
         return wrap(interpreter.heap(), *context);
     }
     return JS::js_undefined();
 }
 
+JS::Value HTMLCanvasElementWrapper::width_getter(JS::Interpreter& interpreter)
+{
+    if (auto* impl = impl_from(interpreter))
+        return JS::Value(impl->preferred_width());
+    return {};
+}
+
+JS::Value HTMLCanvasElementWrapper::height_getter(JS::Interpreter& interpreter)
+{
+    if (auto* impl = impl_from(interpreter))
+        return JS::Value(impl->preferred_height());
+    return {};
+}
+
 }
 }

Libraries/LibWeb/Bindings/HTMLCanvasElementWrapper.h

@@ -43,6 +43,9 @@ private:
     virtual const char* class_name() const override { return "HTMLCanvasElementWrapper"; }
 
     static JS::Value get_context(JS::Interpreter&);
+
+    static JS::Value width_getter(JS::Interpreter&);
+    static JS::Value height_getter(JS::Interpreter&);
 };
 
 }

Libraries/LibWeb/Bindings/MouseEventWrapper.cpp

@@ -24,8 +24,9 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <AK/Function.h>
 #include <AK/FlyString.h>
+#include <AK/Function.h>
+#include <LibJS/Interpreter.h>
 #include <LibJS/Runtime/Function.h>
 #include <LibWeb/Bindings/MouseEventWrapper.h>
 #include <LibWeb/DOM/MouseEvent.h>
@@ -36,18 +37,8 @@ namespace Bindings {
 MouseEventWrapper::MouseEventWrapper(MouseEvent& event)
     : EventWrapper(event)
 {
-    put_native_property(
-        "offsetX",
-        [this](JS::Object*) {
-            return JS::Value(this->event().offset_x());
-        },
-        nullptr);
-    put_native_property(
-        "offsetY",
-        [this](JS::Object*) {
-            return JS::Value(this->event().offset_y());
-        },
-        nullptr);
+    put_native_property("offsetX", offset_x_getter, nullptr);
+    put_native_property("offsetY", offset_y_getter, nullptr);
 }
 
 MouseEventWrapper::~MouseEventWrapper()
@@ -64,5 +55,28 @@ MouseEvent& MouseEventWrapper::event()
     return static_cast<MouseEvent&>(EventWrapper::event());
 }
 
+static MouseEvent* impl_from(JS::Interpreter& interpreter)
+{
+    auto* this_object = interpreter.this_value().to_object(interpreter.heap());
+    if (!this_object)
+        return nullptr;
+    // FIXME: Verify that it's a CanvasRenderingContext2DWrapper somehow!
+    return &static_cast<MouseEventWrapper*>(this_object)->event();
+}
+
+JS::Value MouseEventWrapper::offset_x_getter(JS::Interpreter& interpreter)
+{
+    if (auto* impl = impl_from(interpreter))
+        return JS::Value(impl->offset_x());
+    return {};
+}
+
+JS::Value MouseEventWrapper::offset_y_getter(JS::Interpreter& interpreter)
+{
+    if (auto* impl = impl_from(interpreter))
+        return JS::Value(impl->offset_y());
+    return {};
+}
+
 }
 }

Libraries/LibWeb/Bindings/MouseEventWrapper.h

@@ -41,6 +41,9 @@ public:
 
 private:
     virtual const char* class_name() const override { return "MouseEventWrapper"; }
+
+    static JS::Value offset_x_getter(JS::Interpreter&);
+    static JS::Value offset_y_getter(JS::Interpreter&);
 };
 
 }

Libraries/LibWeb/DOM/Document.cpp

@@ -392,7 +392,7 @@ JS::Interpreter& Document::interpreter()
 
         m_interpreter->global_object().put_native_property(
             "document",
-            [this](JS::Object*) {
+            [this](JS::Interpreter&) {
                 return wrap(m_interpreter->heap(), *this);
             },
             nullptr);