no bloom bytes

1 files changed, 9 insertions, 14 deletions

diff --git a/src/document/sync.rs b/src/document/sync.rs
index 1fc5589..bfa0fef 100644
--- a/src/document/sync.rs
+++ b/src/document/sync.rs
@@ -97,16 +97,9 @@ impl Received {
         &self.0.heads
     }
 
-    /// The bytes of the changes it carries, and of its bloom filters (`have`).
-    pub(crate) fn sizes(&self) -> (usize, usize) {
-        let changes = self.0.changes.iter().map(<[u8]>::len).sum();
-        let blooms = self
-            .0
-            .have
-            .iter()
-            .map(|have| have.bloom.to_bytes().len())
-            .sum();
-        (changes, blooms)
+    /// The bytes of the changes it carries.
+    pub(crate) fn change_bytes(&self) -> usize {
+        self.0.changes.iter().map(<[u8]>::len).sum()
     }
 }
 
@@ -1423,7 +1416,7 @@ mod tests {
         }
         assert_eq!(theirs.get_heads(), ours.get_heads());
         if let Some(answer) = b.generate(&theirs, now, bytes) {
-            let (carried, _) = decode(&answer).unwrap().sizes();
+            let carried = decode(&answer).unwrap().change_bytes();
             assert_eq!(carried, 0, "a's own changes went back to it");
         }
     }
@@ -1493,7 +1486,7 @@ mod tests {
         a.known_to_peer(&ours.get_heads(), Instant::now());
         let message = a.generate(&ours, now, bytes).expect("our heads moved");
         a.send_succeeded(a.id());
-        let (carried, _) = decode(&message).unwrap().sizes();
+        let carried = decode(&message).unwrap().change_bytes();
         assert_eq!(carried, 0, "not sent: the peer gets it from elsewhere");
 
         // It didn't: it asks, and gets it.
@@ -1631,13 +1624,15 @@ mod tests {
                 b.came_from_peer(&theirs, &before);
                 let level = b.answered_as_delivered(&theirs, &theirs.get_heads());
                 let answer = b.generate(&theirs, now, bytes).map(|m| decode(&m).unwrap());
-                let answered = answer.as_ref().map(|m| (m.heads().to_vec(), m.sizes().0));
+                let answered = answer
+                    .as_ref()
+                    .map(|m| (m.heads().to_vec(), m.change_bytes()));
                 if let Some(answer) = answer {
                     a.receive(&mut ours, answer).unwrap();
                 }
                 let next = a
                     .generate(&ours, now, bytes)
-                    .map(|m| decode(&m).unwrap().sizes().0);
+                    .map(|m| decode(&m).unwrap().change_bytes());
                 (theirs.get_heads(), level, answered, ours.get_heads(), next)
             };
             assert_eq!(outcome(true), outcome(false), "concurrent: {concurrent}");