optimize encode_script_with_permission

Author: atuchin-m

src/cosmetic_filter_cache_builder.rs

@@ -171,24 +171,24 @@ impl CosmeticFilterCacheBuilder {
             .chain(rule.hostnames.unwrap_or_default())
             .chain(rule.entities.unwrap_or_default());
 
-        tokens_to_insert.for_each(|t| self.store_hostname_filter(&t, kind.clone()));
+        tokens_to_insert.for_each(|t| self.store_hostname_filter(&t, &kind));
 
         let tokens_to_insert_negated = std::iter::empty()
             .chain(rule.not_hostnames.unwrap_or_default())
             .chain(rule.not_entities.unwrap_or_default());
 
         let negated = kind.negated();
 
-        tokens_to_insert_negated.for_each(|t| self.store_hostname_filter(&t, negated.clone()));
+        tokens_to_insert_negated.for_each(|t| self.store_hostname_filter(&t, &negated));
     }
 
-    fn store_hostname_filter(&mut self, token: &Hash, kind: SpecificFilterType) {
+    fn store_hostname_filter(&mut self, token: &Hash, kind: &SpecificFilterType) {
         use SpecificFilterType::*;
 
         match kind {
             // Handle hide and inject_script at top level for better deduplication
             Hide(s) => {
-                self.hostname_hide.insert(*token, s);
+                self.hostname_hide.insert(*token, s.clone());
             }
             InjectScript((s, permission)) => {
                 let encoded_script = encode_script_with_permission(s, permission);
@@ -197,19 +197,19 @@ impl CosmeticFilterCacheBuilder {
             // Handle remaining types through HostnameRule
             Unhide(s) => {
                 let entry = self.specific_rules.entry(*token).or_default();
-                entry.unhide.push(s);
+                entry.unhide.push(s.clone());
             }
             UninjectScript((s, _)) => {
                 let entry = self.specific_rules.entry(*token).or_default();
-                entry.uninject_script.push(s);
+                entry.uninject_script.push(s.clone());
             }
             ProceduralOrAction(s) => {
                 let entry = self.specific_rules.entry(*token).or_default();
-                entry.procedural_action.push(s);
+                entry.procedural_action.push(s.clone());
             }
             ProceduralOrActionException(s) => {
                 let entry = self.specific_rules.entry(*token).or_default();
-                entry.procedural_action_exception.push(s);
+                entry.procedural_action_exception.push(s.clone());
             }
         }
     }

src/cosmetic_filter_utils.rs

@@ -86,17 +86,16 @@ impl SpecificFilterType {
 
 /// Encodes permission bits in the last 2 ascii chars of a script string
 /// Returns the script with permission appended
-pub(crate) fn encode_script_with_permission(
-    mut script: String,
-    permission: PermissionMask,
-) -> String {
+pub(crate) fn encode_script_with_permission(script: &str, permission: &PermissionMask) -> String {
     const HEX_CHARS: &[u8; 16] = b"0123456789abcdef";
     let high = (permission.to_bits() >> 4) as usize;
     let low = (permission.to_bits() & 0x0f) as usize;
 
-    script.push(HEX_CHARS[high] as char);
-    script.push(HEX_CHARS[low] as char);
-    script
+    let mut encoded_script = String::with_capacity(script.len() + 2);
+    encoded_script.push_str(script);
+    encoded_script.push(HEX_CHARS[high] as char);
+    encoded_script.push(HEX_CHARS[low] as char);
+    encoded_script
 }
 
 /// Decodes permission bits from the last 2 ascii chars of a script string
@@ -133,7 +132,7 @@ mod tests {
             let script = "console.log('测试 🚀 emoji')".to_string();
             let permission = PermissionMask::from_bits(permission);
 
-            let encoded = encode_script_with_permission(script.clone(), permission);
+            let encoded = encode_script_with_permission(&script, &permission);
             let (decoded_permission, decoded_script) = decode_script_with_permission(&encoded);
 
             assert_eq!(decoded_permission.to_bits(), permission.to_bits());