Apply clippy recommendations

Signed-off-by: webbeef <[e-mail]>

crates/beaver_p2p/src/lib.rs

···
 mod pairing_protocol;
 mod state;
 
-use iroh::SecretKey;
-use packet::PostcardPacket;
 use std::sync::Arc;
-use tokio::task::AbortHandle;
+use std::sync::mpsc::Sender;
 
-use crate::packet::BasePacket;
 use iroh::address_lookup::UserData;
 use iroh::address_lookup::mdns::MdnsAddressLookup;
 use iroh::endpoint::{ClosedStream, ConnectError, ConnectionError, WriteError};
-use iroh::{Endpoint, EndpointId, RelayMode, protocol::Router};
+use iroh::protocol::Router;
+use iroh::{Endpoint, EndpointId, RelayMode, SecretKey};
 use log::{error, info};
 use n0_future::StreamExt;
-use std::sync::mpsc::Sender;
+use packet::PostcardPacket;
 use thiserror::Error;
 use tokio::sync::Mutex;
+use tokio::task::AbortHandle;
 
+use crate::packet::BasePacket;
 use crate::pairing_hook::{MESSAGE_ALPN, PAIRING_ALPN};
-pub use crate::state::EndpointStatus;
-pub use crate::state::PeerEvent;
 use crate::state::{EndpointDescription, PairingCommand, SharedState, State};
+pub use crate::state::{EndpointStatus, PeerEvent};
 
 #[derive(Debug, Error)]
 pub enum PairingError {
···
             PairingCommand::Request => {
                 error!("Unexpected Request in response to a pairing request");
                 return Err(PairingError::InvalidState);
-            }
+            },
             PairingCommand::Ack => {
                 error!("Unexpected Ack in response to a pairing request");
                 return Err(PairingError::InvalidState);
-            }
+            },
         };
 
         // Send Ack
···
             .await;
         println!("accept_pairing ok 3");
         let mut state = inner.state.lock().await;
-        let res = res.map(|_| {
+        res.map(|_| {
             // Add the endpoint to the set of pending acks if successfully sending.
             state.set_pending_ack(from);
-        });
-        res
+        })
     }
 
     // Reject a pairing request
···
                             .lock()
                             .await
                             .notify(PeerEvent::Message(remote_id, payload));
-                    }
+                    },
                     Err(err) => {
                         error!("Error reading message packet: {err}");
                         break;
-                    }
+                    },
                 }
             }
         });

crates/beaver_p2p/src/main.rs

···
+use std::sync::mpsc::channel;
+
+use beaver_p2p::{PairingManager, PeerEvent};
 use iroh::address_lookup::DiscoveryEvent;
 use log::info;
-use beaver_p2p::{PairingManager, PeerEvent};
-use std::sync::mpsc::channel;
 
 #[tokio::main]
 async fn main() {
···
                     if start_pairing {
                         let _ = manager.request_pairing(&endpoint_info.endpoint_id).await;
                     }
-                }
+                },
                 PeerEvent::Discovery(DiscoveryEvent::Expired { endpoint_id }) => {
                     info!("MDNS expired: {endpoint_id}");
-                }
+                },
                 PeerEvent::PairingRequest(endpoint_id) => {
                     info!("Accepting pairing request from {endpoint_id}");
                     manager
                         .accept_pairing(&endpoint_id)
                         .await
                         .expect("Failed to accept");
-                }
+                },
                 PeerEvent::PairingAccepted(endpoint_id) => {
                     info!("Pairing accepted from {endpoint_id}");
-                }
+                },
                 PeerEvent::PairingRejected(endpoint_id) => {
                     info!("Pairing rejected from {endpoint_id}");
-                }
+                },
                 PeerEvent::PairingFailed(endpoint_id) => {
                     info!("Pairing failed with {endpoint_id}");
-                }
+                },
                 PeerEvent::Message(endpoint_id, payload) => {
                     info!("Message of {} bytes from {}", payload.len(), endpoint_id);
-                }
+                },
             },
             Err(err) => {
                 println!("Channel closed: {err}");
                 break;
-            }
+            },
         }
     }
 }

crates/beaver_p2p/src/message_protocol.rs

···
 /* SPDX Id: AGPL-3.0-or-later */
 
-use iroh::{
-    endpoint::Connection,
-    protocol::{AcceptError, ProtocolHandler},
-};
+use iroh::endpoint::Connection;
+use iroh::protocol::{AcceptError, ProtocolHandler};
 use log::{error, info};
 
-use crate::{PeerEvent, packet::BasePacket, state::SharedState};
+use crate::PeerEvent;
+use crate::packet::BasePacket;
+use crate::state::SharedState;
 
 #[derive(Debug)]
 pub(crate) struct MessageProtocol {
···
                         .lock()
                         .await
                         .notify(PeerEvent::Message(remote_id, payload));
-                }
+                },
                 Err(err) => {
                     error!("Error reading message packet: {err}");
                     break;
-                }
+                },
             }
         }
 

crates/beaver_p2p/src/pairing_hook.rs

···
 use iroh::endpoint::{AfterHandshakeOutcome, ConnectionInfo, EndpointHooks, Side};
 use log::info;
 
-use crate::state::EndpointStatus;
-use crate::state::SharedState;
+use crate::state::{EndpointStatus, SharedState};
 
 pub(crate) static PAIRING_ALPN: &[u8] = b"beaver-web/pairing/1";
 pub(crate) static MESSAGE_ALPN: &[u8] = b"beaver-web/message/1";
···
         );
 
         // For message protocol, only allow PairedConnected endpoints.
-        if conn.alpn() == MESSAGE_ALPN
-            && !self
+        if conn.alpn() == MESSAGE_ALPN &&
+            !self
                 .state
                 .lock()
                 .await

crates/beaver_p2p/src/pairing_protocol.rs

···
 use iroh::endpoint::Connection;
 use iroh::protocol::{AcceptError, ProtocolHandler};
 use log::{error, info};
-
 use tokio::sync::mpsc::channel as tokio_channel;
 
 use crate::packet::PostcardPacket;
···
                     .lock()
                     .await
                     .notify(PeerEvent::PairingRequest(remote_id));
-            }
+            },
             _ => {
                 error!("Unexpected command: {command:?}");
                 return Err(AcceptError::from(n0_error::AnyError::from(format!(
                     "Unexpected command: {command:?}"
                 ))));
-            }
+            },
         }
 
         let (tokio_sender, mut tokio_receiver) = tokio_channel(2);
···
                     }
                 }
                 let _ = ack_sender.send(true).await;
-            }
+            },
             _ => {
                 self.state
                     .lock()
···
                 return Err(AcceptError::from(n0_error::AnyError::from(format!(
                     "Unexpected command: {command:?}"
                 ))));
-            }
+            },
         }
 
         Ok(())

crates/beaver_p2p/src/state.rs

···
 /* SPDX Id: AGPL-3.0-or-later */
 
-use std::{
-    collections::{HashMap, HashSet},
-    sync::Arc,
-};
+use std::collections::{HashMap, HashSet};
+use std::sync::Arc;
+use std::sync::mpsc::Sender;
 
-use iroh::{EndpointAddr, EndpointId, address_lookup::DiscoveryEvent, endpoint::SendStream};
-
+use iroh::address_lookup::DiscoveryEvent;
+use iroh::endpoint::SendStream;
+use iroh::{EndpointAddr, EndpointId};
 use log::{info, warn};
 use serde::{Deserialize, Serialize};
-use std::sync::mpsc::Sender;
 use tokio::sync::Mutex;
 use tokio::sync::mpsc::{Receiver as TokioReceiver, Sender as TokioSender};
 
···
     }
 
     pub(crate) fn is_paired(&self) -> bool {
-        self.status == EndpointStatus::PairedConnected
-            || self.status == EndpointStatus::PairedDisconnected
+        self.status == EndpointStatus::PairedConnected ||
+            self.status == EndpointStatus::PairedDisconnected
     }
 }
 
···
                 self.endpoints
                     .insert(endpoint_info.endpoint_id, description);
                 self.notify(PeerEvent::Discovery(event.clone()));
-            }
+            },
             DiscoveryEvent::Expired { endpoint_id } => {
                 // PairedConnected -> PairedDisconnected
                 // Discovered -> removed
···
                     }
                     self.notify(PeerEvent::Discovery(event.clone()));
                 }
-            }
+            },
         }
     }
 }

crates/beaver_p2p/tests/pairing.rs

···
-use iroh::{EndpointId, address_lookup::DiscoveryEvent};
-use p2p_beaver::{EndpointStatus, MessageError, PairingError, PairingManager, PeerEvent};
-use parking_lot::Mutex;
 use std::sync::Arc;
 use std::sync::mpsc::{Receiver, channel};
+
+use iroh::EndpointId;
+use iroh::address_lookup::DiscoveryEvent;
+use p2p_beaver::{EndpointStatus, MessageError, PairingError, PairingManager, PeerEvent};
+use parking_lot::Mutex;
 
 type PairingReceiver = Receiver<PeerEvent>;
 
···
                 Ok(event) => match event {
                     PeerEvent::Discovery(DiscoveryEvent::Discovered { endpoint_info, .. }) => {
                         return endpoint_info.endpoint_id;
-                    }
-                    _ => {}
+                    },
+                    _ => {},
                 },
                 Err(err) => {
                     panic!("Should not error! {err:?}");
-                }
+                },
             }
         }
     });
···
                 Ok(event) => match event {
                     PeerEvent::Discovery(DiscoveryEvent::Discovered { endpoint_info, .. }) => {
                         return endpoint_info.endpoint_id;
-                    }
-                    _ => {}
+                    },
+                    _ => {},
                 },
                 Err(err) => {
                     panic!("Should not error! {err:?}");
-                }
+                },
             }
         }
     });
···
 macro_rules! assert_pairing {
     ($observed:expr, $expected:pat) => {
         match $observed.err().unwrap() {
-            $expected => {}
+            $expected => {},
             _ => panic!("expected: {{$expected}} but got {{$observed}}"),
         }
     };
···
                         let endpoint_name = format!("{}", endpoint_info.user_data().unwrap());
                         assert_eq!(endpoint_name, "test-2");
                         break;
-                    }
-                    _ => {}
+                    },
+                    _ => {},
                 },
                 Err(_err) => {
                     break;
-                }
+                },
             }
         }
     });
···
                         let endpoint_name = format!("{}", endpoint_info.user_data().unwrap());
                         assert_eq!(endpoint_name, "test-1");
                         break;
-                    }
-                    _ => {}
+                    },
+                    _ => {},
                 },
                 Err(_err) => {
                     break;
-                }
+                },
             }
         }
     });
···
                         }) => {
                             let endpoint_name = format!("{}", endpoint_info.user_data().unwrap());
                             assert_eq!(endpoint_name, "test-2");
-                        }
+                        },
                         PeerEvent::Discovery(DiscoveryEvent::Expired { endpoint_id }) => {
                             assert_eq!(endpoint_id, endpoint2);
                             break;
-                        }
-                        _ => {}
+                        },
+                        _ => {},
                     }
-                }
+                },
                 Err(_err) => {
                     break;
-                }
+                },
             }
         }
     });
···
                         PeerEvent::PairingRejected(endpoint) => {
                             assert_eq!(endpoint, endpoint1);
                             break;
-                        }
-                        _ => {}
+                        },
+                        _ => {},
                     }
-                }
+                },
                 Err(_err) => {
                     break;
-                }
+                },
             }
         }
     });
···
                                     .await
                                     .expect("failed to reject pairing");
                             });
-                        }
+                        },
                         PeerEvent::PairingRejected(endpoint) => {
                             assert_eq!(endpoint, endpoint2);
                             break;
-                        }
-                        _ => {}
+                        },
+                        _ => {},
                     }
-                }
+                },
                 Err(_err) => {
                     break;
-                }
+                },
             }
         }
     });
···
                         PeerEvent::PairingAccepted(endpoint) => {
                             assert_eq!(endpoint, endpoint1);
                             break;
-                        }
-                        _ => {}
+                        },
+                        _ => {},
                     }
-                }
+                },
                 Err(_err) => {
                     break;
-                }
+                },
             }
         }
     });
···
                                     .await
                                     .expect("failed to accept pairing");
                             });
-                        }
+                        },
                         PeerEvent::PairingAccepted(endpoint) => {
                             assert_eq!(endpoint, endpoint2);
                             break;
-                        }
-                        _ => {}
+                        },
+                        _ => {},
                     }
-                }
+                },
                 Err(_err) => {
                     break;
-                }
+                },
             }
         }
     });
···
     let result = manager1.send_message(&endpoint1, b"Hello").await;
     assert!(result.is_err());
     match result {
-        Err(MessageError::Unpaired) => {}
+        Err(MessageError::Unpaired) => {},
         _ => panic!("Unexpected error: {result:?}"),
     }
 
···
                             assert_eq!(endpoint, endpoint1);
                             assert_eq!(data, b"World");
                             break;
-                        }
-                        _ => {}
+                        },
+                        _ => {},
                     }
-                }
+                },
                 Err(_err) => {
                     break;
-                }
+                },
             }
         }
     });
···
                             });
 
                             break;
-                        }
-                        _ => {}
+                        },
+                        _ => {},
                     }
-                }
+                },
                 Err(_err) => {
                     break;
-                }
+                },
             }
         }
     });

crates/beaver_shell/src/main.rs

···
     }
 
     fn window_if_system_webview(&self, webview: &WebView) -> Option<Rc<BrowserWindow>> {
-        let Some(ref window) = self.window_for_webview_id(webview.id()) else {
-            return None;
-        };
+        let binding = self.window_for_webview_id(webview.id());
+        let window = binding.as_ref()?;
 
-        let Some(system_webview_id) = window.system_webview_id.get() else {
-            return None;
-        };
+        let system_webview_id = window.system_webview_id.get()?;
 
         if webview.id() != system_webview_id {
             return None;

patches/components/constellation/constellation.rs.patch

···
 +            ScriptToConstellationMessage::EmbeddedWebViewSetPageZoom(embedded_webview_id, zoom) => {
 +                // Validate this is a known embedded webview
 +                let ctx_id = BrowsingContextId::from(embedded_webview_id);
-+                if self.browsing_contexts.get(&ctx_id).is_none() {
++                if !self.browsing_contexts.contains_key(&ctx_id) {
 +                    return warn!(
 +                        "EmbeddedWebViewSetPageZoom for unknown browsing context {:?}",
 +                        embedded_webview_id

patches/components/constellation/pairing.rs.patch

···
 --- original
 +++ modified
-@@ -0,0 +1,256 @@
+@@ -0,0 +1,255 @@
 +// SPDX-License-Identifier: AGPL-3.0-or-later
 +
 +//! P2P pairing service integration with the constellation.
···
 +use base::generic_channel::GenericCallback;
 +use beaver_p2p::{EndpointStatus, PairingManager, PeerEvent};
 +use constellation_traits::{LocalPeerInfo, PairingEvent, PeerInfo, PeerStatus};
-+use crossbeam_channel;
 +use iroh::address_lookup::DiscoveryEvent;
 +use log::{info, warn};
 +use tokio::sync::Mutex;

patches/components/layout/display_list/mod.rs.patch

···
 +
 +            let root_scroll_spatial_id = self.wr().define_scroll_frame(
 +                zoom_spatial_id,
-+                ExternalScrollId(0, pipeline_id.into()),
++                ExternalScrollId(0, pipeline_id),
 +                content_rect,
 +                clip_rect,
 +                LayoutVector2D::zero(), /* external_scroll_offset */

patches/components/paint/webview_renderer.rs.patch

···
      /// Returns the [`PipelineDetails`] for the given [`PipelineId`], creating it if needed.
      pub(crate) fn ensure_pipeline_details(
          &mut self,
-@@ -364,10 +391,9 @@
+@@ -359,16 +386,14 @@
+             .map(|point| point.as_device_point(self.device_pixels_per_page_pixel()));
+         let hit_test_result = match event_point {
+             Some(point) => {
+-                let hit_test_result = match event.event {
++                // Even if WebRender hit test returns empty, we still send the event to
++                // the script thread for DOM hit testing. The script thread will use the
++                // original event point for DOM hit testing when hit_test_result is None.
++                match event.event {
+                     InputEvent::Touch(_) => self.touch_handler.get_hit_test_result_cache_value(),
                      _ => None,
                  }
-                 .or_else(|| self.hit_test(render_api, point).into_iter().nth(0));
+-                .or_else(|| self.hit_test(render_api, point).into_iter().nth(0));
 -                if hit_test_result.is_none() {
 -                    warn!("Empty hit test result for input event, ignoring.");
 -                    return false;
 -                }
-+                // Even if WebRender hit test returns empty, we still send the event to
-+                // the script thread for DOM hit testing. The script thread will use the
-+                // original event point for DOM hit testing when hit_test_result is None.
-                 hit_test_result
+-                hit_test_result
++                .or_else(|| self.hit_test(render_api, point).into_iter().nth(0))
              },
              None => None,
-@@ -699,6 +725,88 @@
+         };
+@@ -699,6 +724,88 @@
          self.on_scroll_window_event(scroll, point);
      }
 
···
      fn on_scroll_window_event(&mut self, scroll: Scroll, cursor: DevicePoint) {
          self.pending_scroll_zoom_events
              .push(ScrollZoomEvent::Scroll(ScrollEvent {
-@@ -708,18 +816,25 @@
+@@ -708,18 +815,25 @@
              }));
      }
 
···
          }
 
          // Batch up all scroll events and changes to pinch zoom into a single change, or
-@@ -773,15 +888,24 @@
+@@ -773,15 +887,24 @@
              }
          }
 
···
 
          let scroll_result = combined_scroll_event.and_then(|combined_event| {
              self.scroll_node_at_device_point(
-@@ -790,6 +914,21 @@
+@@ -790,6 +913,21 @@
                  combined_event.scroll,
              )
          });
···
          if let Some(ref scroll_result) = scroll_result {
              self.send_scroll_positions_to_layout_for_pipeline(
                  scroll_result.hit_test_result.pipeline_id,
-@@ -805,7 +944,11 @@
+@@ -805,7 +943,11 @@
              self.send_pinch_zoom_infos_to_script();
          }
 
···
      }
 
      /// Perform a hit test at the given [`DevicePoint`] and apply the [`Scroll`]
-@@ -812,7 +955,7 @@
+@@ -812,7 +954,7 @@
      /// scrolling to the applicable scroll node under that point. If a scroll was
      /// performed, returns the hit test result contains [`PipelineId`] of the node
      /// scrolled, the id, and the final scroll delta.
···
          &mut self,
          render_api: &RenderApi,
          cursor: DevicePoint,
-@@ -840,7 +983,10 @@
+@@ -840,7 +982,10 @@
          // its ancestor pipelines.
          let mut previous_pipeline_id = None;
          for hit_test_result in hit_test_results {
···
              if previous_pipeline_id.replace(hit_test_result.pipeline_id) !=
                  Some(hit_test_result.pipeline_id)
              {
-@@ -867,7 +1013,11 @@
+@@ -867,7 +1012,11 @@
                  }
              }
          }
···
      }
 
      /// Scroll the viewport (root pipeline, root scroll node) of this WebView, but first
-@@ -1006,20 +1156,45 @@
+@@ -1006,20 +1155,45 @@
      }
 
      fn send_window_size_message(&self) {
···
      }
 
      /// Set the `hidpi_scale_factor` for this renderer, returning `true` if the value actually changed.
-@@ -1085,8 +1260,21 @@
+@@ -1085,8 +1259,21 @@
          if let Some(wheel_event) = self.pending_wheel_events.remove(&id) {
              if !result.contains(InputEventResult::DefaultPrevented) {
                  // A scroll delta for a wheel event is the inverse of the wheel delta.

patches/components/script/dom/document_event_handler.rs.patch

···
 +
 +        // Convert iframe position from document coords to viewport coords by subtracting scroll offset.
 +        let scroll_offset = self.window.scroll_offset();
-+        let iframe_viewport_x = iframe_border_box.origin.x.to_f32_px() - scroll_offset.x as f32;
-+        let iframe_viewport_y = iframe_border_box.origin.y.to_f32_px() - scroll_offset.y as f32;
++        let iframe_viewport_x = iframe_border_box.origin.x.to_f32_px() - scroll_offset.x;
++        let iframe_viewport_y = iframe_border_box.origin.y.to_f32_px() - scroll_offset.y;
 +
 +        // Get device pixel ratio for converting between CSS and device pixels
 +        let device_pixel_ratio = self.window.device_pixel_ratio().get();
···
 +
 +        // Convert iframe position from document coords to viewport coords
 +        let scroll_offset = self.window.scroll_offset();
-+        let iframe_viewport_x = iframe_border_box.origin.x.to_f32_px() - scroll_offset.x as f32;
-+        let iframe_viewport_y = iframe_border_box.origin.y.to_f32_px() - scroll_offset.y as f32;
++        let iframe_viewport_x = iframe_border_box.origin.x.to_f32_px() - scroll_offset.x;
++        let iframe_viewport_y = iframe_border_box.origin.y.to_f32_px() - scroll_offset.y;
 +
 +        // Get device pixel ratio for coordinate conversion
 +        let device_pixel_ratio = self.window.device_pixel_ratio().get();

patches/components/script/dom/pairingpeerevent.rs.patch

···
 +        init: &PairingPeerEventInit,
 +    ) -> Fallible<DomRoot<PairingPeerEvent>> {
 +        Ok(PairingPeerEvent::new_with_proto(
-+            &window.upcast::<GlobalScope>(),
++            window.upcast::<GlobalScope>(),
 +            proto,
 +            Atom::from(type_),
 +            init.parent.bubbles,

patches/components/script/dom/window.rs.patch

···
 +        // Verify the node belongs to this window's document
 +        let node_doc = node.owner_doc();
 +        let our_doc = self.Document();
-+        if &*node_doc != &*our_doc {
++        if *node_doc != *our_doc {
 +            warn!(
 +                "hit_test_from_point_in_viewport: node {:?} belongs to different document! \
 +                 Node doc URL: {:?}, Our doc URL: {:?}",