Internal: Rethink mutations writer (#731)

* internal: Simplify the `VirtualDOM` polling

* internal: Rethink the MutationsWriter impl of freya

* clippy

Author: marc2332

crates/core/src/dom/dom_adapter.rs

@@ -10,19 +10,56 @@ use torin::prelude::*;
 
 use crate::dom::DioxusDOM;
 
+pub enum DioxusDOMAdapterCache<'a> {
+    Controlled(&'a mut FxHashMap<NodeId, bool>),
+    Provided(FxHashMap<NodeId, bool>),
+}
+
+impl DioxusDOMAdapterCache<'_> {
+    fn is_valid(&self, node_id: NodeId) -> Option<bool> {
+        let map = match self {
+            Self::Controlled(map) => map,
+            Self::Provided(map) => map,
+        };
+
+        map.get(&node_id).copied()
+    }
+
+    fn insert(&mut self, node_id: NodeId, is_valid: bool) {
+        let map = match self {
+            Self::Controlled(map) => map,
+            Self::Provided(map) => map,
+        };
+
+        map.insert(node_id, is_valid);
+    }
+}
+
 /// RealDOM adapter for Torin.
 pub struct DioxusDOMAdapter<'a> {
     pub rdom: &'a DioxusDOM,
     pub scale_factor: f32,
-    valid_nodes_cache: Option<FxHashMap<NodeId, bool>>,
+    cache: DioxusDOMAdapterCache<'a>,
 }
 
 impl<'a> DioxusDOMAdapter<'a> {
-    pub fn new_with_cache(rdom: &'a DioxusDOM, scale_factor: f32) -> Self {
+    pub fn new(rdom: &'a DioxusDOM, scale_factor: f32) -> Self {
         Self {
             rdom,
             scale_factor,
-            valid_nodes_cache: Some(FxHashMap::default()),
+            cache: DioxusDOMAdapterCache::Provided(FxHashMap::default()),
+        }
+    }
+
+    pub fn new_with_cache(
+        rdom: &'a mut DioxusDOM,
+        scale_factor: f32,
+        cache: DioxusDOMAdapterCache<'a>,
+    ) -> Self {
+        Self {
+            rdom,
+            scale_factor,
+            cache,
         }
     }
 }
@@ -79,12 +116,12 @@ impl DOMAdapter<NodeId> for DioxusDOMAdapter<'_> {
 
     fn children_of(&mut self, node_id: &NodeId) -> Vec<NodeId> {
         let mut children = self.rdom.tree_ref().children_ids(*node_id);
-        children.retain(|id| is_node_valid(self.rdom, &mut self.valid_nodes_cache, id));
+        children.retain(|id| is_node_valid(self.rdom, &mut self.cache, id));
         children
     }
 
     fn is_node_valid(&mut self, node_id: &NodeId) -> bool {
-        is_node_valid(self.rdom, &mut self.valid_nodes_cache, node_id)
+        is_node_valid(self.rdom, &mut self.cache, node_id)
     }
 
     fn root_id(&self) -> NodeId {
@@ -93,16 +130,10 @@ impl DOMAdapter<NodeId> for DioxusDOMAdapter<'_> {
 }
 
 /// Check is the given Node is valid or not, this means not being a placeholder or an unconnected Node.
-fn is_node_valid(
-    rdom: &DioxusDOM,
-    valid_nodes_cache: &mut Option<FxHashMap<NodeId, bool>>,
-    node_id: &NodeId,
-) -> bool {
+fn is_node_valid(rdom: &DioxusDOM, cache: &mut DioxusDOMAdapterCache, node_id: &NodeId) -> bool {
     // Check if Node was valid from cache
-    if let Some(valid_nodes_cache) = valid_nodes_cache {
-        if let Some(is_valid) = valid_nodes_cache.get(node_id) {
-            return *is_valid;
-        }
+    if let Some(is_valid) = cache.is_valid(*node_id) {
+        return is_valid;
     }
 
     let node = rdom.get(*node_id);
@@ -142,9 +173,7 @@ fn is_node_valid(
     };
 
     // Save the validation result in the cache
-    if let Some(valid_nodes_cache) = valid_nodes_cache {
-        valid_nodes_cache.insert(*node_id, is_valid);
-    }
+    cache.insert(*node_id, is_valid);
 
     is_valid
 }

crates/core/src/dom/doms.rs

@@ -34,6 +34,7 @@ use freya_node_state::{
     TransformState,
     ViewportState,
 };
+use rustc_hash::FxHashMap;
 use torin::prelude::*;
 use tracing::info;
 
@@ -162,12 +163,12 @@ impl FreyaDOM {
     pub fn init_dom(&mut self, vdom: &mut VirtualDom, scale_factor: f32) {
         // Build the RealDOM
         vdom.rebuild(&mut MutationsWriter {
-            native_writer: self
-                .dioxus_integration_state
-                .create_mutation_writer(&mut self.rdom),
+            dioxus_integration_state: &mut self.dioxus_integration_state,
             layout: &mut self.torin.lock().unwrap(),
             layers: &self.layers,
             paragraphs: &self.paragraphs,
+            rdom: &mut self.rdom,
+            dioxus_dom_adapter_cache: &mut FxHashMap::default(),
             scale_factor,
         });
 
@@ -183,12 +184,12 @@ impl FreyaDOM {
     pub fn render_mutations(&mut self, vdom: &mut VirtualDom, scale_factor: f32) -> (bool, bool) {
         // Update the RealDOM
         vdom.render_immediate(&mut MutationsWriter {
-            native_writer: self
-                .dioxus_integration_state
-                .create_mutation_writer(&mut self.rdom),
+            dioxus_integration_state: &mut self.dioxus_integration_state,
             layout: &mut self.torin.lock().unwrap(),
             layers: &self.layers,
             paragraphs: &self.paragraphs,
+            rdom: &mut self.rdom,
+            dioxus_dom_adapter_cache: &mut FxHashMap::default(),
             scale_factor,
         });
 
@@ -229,7 +230,7 @@ impl FreyaDOM {
     }
 
     /// Measure all the paragraphs registered under the given TextId
-    pub fn measure_paragraphs(&self, text_measurement: TextGroupMeasurement, scale_factor: f32) {
+    pub fn measure_paragraphs(&self, text_measurement: TextGroupMeasurement, scale_factor: f64) {
         let paragraphs = self.paragraphs.paragraphs();
         let group = paragraphs.get(&text_measurement.text_id);
         let layout = self.layout();

crates/core/src/dom/mutations_writer.rs

@@ -7,42 +7,62 @@ use freya_common::{
     ParagraphElements,
 };
 use freya_native_core::{
-    dioxus::DioxusNativeCoreMutationWriter,
-    prelude::NodeImmutable,
+    prelude::{
+        DioxusState,
+        NodeImmutable,
+    },
     tree::TreeRef,
     NodeId,
 };
 use freya_node_state::{
     CursorState,
-    CustomAttributeValues,
     LayerState,
 };
+use rustc_hash::FxHashMap;
 use torin::torin::Torin;
 
-use crate::prelude::DioxusDOMAdapter;
+use crate::prelude::{
+    DioxusDOM,
+    DioxusDOMAdapter,
+    DioxusDOMAdapterCache,
+};
+
+macro_rules! create_mutation_writer {
+    ($self:ident) => {
+        $self
+            .dioxus_integration_state
+            .create_mutation_writer(&mut $self.rdom)
+    };
+}
 
 pub struct MutationsWriter<'a> {
-    pub native_writer: DioxusNativeCoreMutationWriter<'a, CustomAttributeValues>,
+    pub dioxus_integration_state: &'a mut DioxusState,
     pub layout: &'a mut Torin<NodeId>,
     pub layers: &'a Layers,
     pub paragraphs: &'a ParagraphElements,
+    pub dioxus_dom_adapter_cache: &'a mut FxHashMap<NodeId, bool>,
     pub scale_factor: f32,
+    pub rdom: &'a mut DioxusDOM,
 }
 
 impl<'a> MutationsWriter<'a> {
     pub fn remove(&mut self, id: ElementId) {
-        let node_id = self.native_writer.state.element_to_node_id(id);
-        let mut dom_adapter =
-            DioxusDOMAdapter::new_with_cache(self.native_writer.rdom, self.scale_factor);
+        let node_id = self.dioxus_integration_state.element_to_node_id(id);
+
+        let mut dom_adapter = DioxusDOMAdapter::new_with_cache(
+            self.rdom,
+            self.scale_factor,
+            DioxusDOMAdapterCache::Controlled(self.dioxus_dom_adapter_cache),
+        );
 
         // Remove from layout
         self.layout.remove(node_id, &mut dom_adapter, true);
 
         // Remove from layers and paragraph elements
         let mut stack = vec![node_id];
-        let tree = self.native_writer.rdom.tree_ref();
+        let tree = self.rdom.tree_ref();
         while let Some(node_id) = stack.pop() {
-            if let Some(node) = self.native_writer.rdom.get(node_id) {
+            if let Some(node) = self.rdom.get(node_id) {
                 if !node.node_type().is_visible_element() {
                     continue;
                 }
@@ -75,51 +95,63 @@ impl<'a> MutationsWriter<'a> {
 
 impl<'a> WriteMutations for MutationsWriter<'a> {
     fn register_template(&mut self, template: dioxus_core::prelude::Template) {
-        self.native_writer.register_template(template);
+        let mut native_writer = create_mutation_writer!(self);
+        native_writer.register_template(template);
     }
 
     fn append_children(&mut self, id: dioxus_core::ElementId, m: usize) {
-        self.native_writer.append_children(id, m);
+        let mut native_writer = create_mutation_writer!(self);
+        native_writer.append_children(id, m);
     }
 
     fn assign_node_id(&mut self, path: &'static [u8], id: dioxus_core::ElementId) {
-        self.native_writer.assign_node_id(path, id);
+        let mut native_writer = create_mutation_writer!(self);
+        native_writer.assign_node_id(path, id);
     }
 
     fn create_placeholder(&mut self, id: dioxus_core::ElementId) {
-        self.native_writer.create_placeholder(id);
+        let mut native_writer = create_mutation_writer!(self);
+        native_writer.create_placeholder(id);
     }
 
     fn create_text_node(&mut self, value: &str, id: dioxus_core::ElementId) {
-        self.native_writer.create_text_node(value, id);
+        let mut native_writer = create_mutation_writer!(self);
+        native_writer.create_text_node(value, id);
     }
 
     fn hydrate_text_node(&mut self, path: &'static [u8], value: &str, id: dioxus_core::ElementId) {
-        self.native_writer.hydrate_text_node(path, value, id);
+        let mut native_writer = create_mutation_writer!(self);
+        native_writer.hydrate_text_node(path, value, id);
     }
 
     fn load_template(&mut self, name: &'static str, index: usize, id: dioxus_core::ElementId) {
-        self.native_writer.load_template(name, index, id);
+        let mut native_writer = create_mutation_writer!(self);
+        native_writer.load_template(name, index, id);
     }
 
     fn replace_node_with(&mut self, id: dioxus_core::ElementId, m: usize) {
         if m > 0 {
             self.remove(id);
         }
 
-        self.native_writer.replace_node_with(id, m);
+        let mut native_writer = create_mutation_writer!(self);
+
+        native_writer.replace_node_with(id, m);
     }
 
     fn replace_placeholder_with_nodes(&mut self, path: &'static [u8], m: usize) {
-        self.native_writer.replace_placeholder_with_nodes(path, m);
+        let mut native_writer = create_mutation_writer!(self);
+        native_writer.replace_placeholder_with_nodes(path, m);
     }
 
     fn insert_nodes_after(&mut self, id: dioxus_core::ElementId, m: usize) {
-        self.native_writer.insert_nodes_after(id, m);
+        let mut native_writer = create_mutation_writer!(self);
+        native_writer.insert_nodes_after(id, m);
     }
 
     fn insert_nodes_before(&mut self, id: dioxus_core::ElementId, m: usize) {
-        self.native_writer.insert_nodes_before(id, m);
+        let mut native_writer = create_mutation_writer!(self);
+        native_writer.insert_nodes_before(id, m);
     }
 
     fn set_attribute(
@@ -129,29 +161,33 @@ impl<'a> WriteMutations for MutationsWriter<'a> {
         value: &dioxus_core::AttributeValue,
         id: dioxus_core::ElementId,
     ) {
-        self.native_writer.set_attribute(name, ns, value, id);
+        let mut native_writer = create_mutation_writer!(self);
+        native_writer.set_attribute(name, ns, value, id);
     }
 
     fn set_node_text(&mut self, value: &str, id: dioxus_core::ElementId) {
-        self.layout
-            .invalidate(self.native_writer.state.element_to_node_id(id));
-        self.native_writer.set_node_text(value, id);
+        let mut native_writer = create_mutation_writer!(self);
+        native_writer.set_node_text(value, id);
     }
 
     fn create_event_listener(&mut self, name: &'static str, id: dioxus_core::ElementId) {
-        self.native_writer.create_event_listener(name, id);
+        let mut native_writer = create_mutation_writer!(self);
+        native_writer.create_event_listener(name, id);
     }
 
     fn remove_event_listener(&mut self, name: &'static str, id: dioxus_core::ElementId) {
-        self.native_writer.remove_event_listener(name, id);
+        let mut native_writer = create_mutation_writer!(self);
+        native_writer.remove_event_listener(name, id);
     }
 
     fn remove_node(&mut self, id: dioxus_core::ElementId) {
         self.remove(id);
-        self.native_writer.remove_node(id);
+        let mut native_writer = create_mutation_writer!(self);
+        native_writer.remove_node(id);
     }
 
     fn push_root(&mut self, id: dioxus_core::ElementId) {
-        self.native_writer.push_root(id);
+        let mut native_writer = create_mutation_writer!(self);
+        native_writer.push_root(id);
     }
 }

crates/core/src/layout.rs

@@ -11,13 +11,14 @@ pub fn process_layout(
     fdom: &FreyaDOM,
     area: Area,
     font_collection: &mut FontCollection,
-    scale_factor: f32,
+    scale_factor: f64,
     default_fonts: &[String],
 ) {
     {
         let rdom = fdom.rdom();
-        let mut dom_adapter = DioxusDOMAdapter::new_with_cache(rdom, scale_factor);
-        let skia_measurer = SkiaMeasurer::new(rdom, font_collection, default_fonts, scale_factor);
+        let mut dom_adapter = DioxusDOMAdapter::new(rdom, scale_factor as f32);
+        let skia_measurer =
+            SkiaMeasurer::new(rdom, font_collection, default_fonts, scale_factor as f32);
 
         // Finds the best Node from where to start measuring
         fdom.layout().find_best_root(&mut dom_adapter);

crates/core/src/platform_state.rs

@@ -9,7 +9,7 @@ pub struct NativePlatformState {
     pub preferred_theme: PreferredTheme,
     pub navigation_mode: NavigationMode,
     pub information: PlatformInformation,
-    pub scale_factor: f32,
+    pub scale_factor: f64,
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]