Use larger sample sizes for known requests when possible

httppostargs allow larger requests, and so does ssh/local.

src/hg_connect.rs

@@ -118,6 +118,10 @@ pub trait HgConnectionBase {
             );
         }
     }
+
+    fn sample_size(&self) -> usize {
+        100
+    }
 }
 
 pub trait HgWireConnection: HgConnectionBase {
@@ -317,6 +321,10 @@ impl<C: HgWireConnection> HgConnectionBase for HgWired<C> {
     fn get_capability(&self, name: &[u8]) -> Option<&BStr> {
         self.conn.get_capability(name)
     }
+
+    fn sample_size(&self) -> usize {
+        self.conn.sample_size()
+    }
 }
 
 impl<C: HgWireConnection> HgConnection for HgWired<C> {
@@ -633,8 +641,6 @@ fn take_sample<R: rand::Rng + ?Sized, T>(rng: &mut R, data: &mut Vec<T>, size: u
     }
 }
 
-pub const SAMPLE_SIZE: usize = 100;
-
 #[derive(Default, Debug)]
 struct FindCommonInfo {
     hg_node: Option<HgChangesetId>,
@@ -652,7 +658,8 @@ pub fn find_common(
     if undetermined.is_empty() {
         return vec![];
     }
-    let sample = take_sample(&mut rng, &mut undetermined, SAMPLE_SIZE);
+    let sample_size = conn.sample_size();
+    let sample = take_sample(&mut rng, &mut undetermined, sample_size);
 
     let (known, unknown): (Vec<_>, Vec<_>) =
         conn.known(&sample)
@@ -731,12 +738,12 @@ pub fn find_common(
     }
 
     while undetermined_count > 0 {
-        if undetermined.len() < SAMPLE_SIZE {
+        if undetermined.len() < sample_size {
             undetermined.extend(
                 // TODO: this would or maybe would not be faster if traversing the dag instead.
                 dag.iter_mut()
                     .filter(|(_, data)| data.known.is_none())
-                    .choose_multiple(&mut rng, SAMPLE_SIZE - undetermined.len())
+                    .choose_multiple(&mut rng, sample_size - undetermined.len())
                     .into_iter()
                     .map(|(&c, data)| {
                         let git_cs = GitChangesetId::from_unchecked(c);
@@ -750,7 +757,7 @@ pub fn find_common(
             );
         }
         let (sample_hg, sample_git): (Vec<_>, Vec<_>) =
-            take_sample(&mut rng, &mut undetermined, SAMPLE_SIZE)
+            take_sample(&mut rng, &mut undetermined, sample_size)
                 .into_iter()
                 .unzip();
         for (&known, &c) in conn.known(&sample_hg).iter().zip(sample_git.iter()) {

src/hg_connect_http.rs

@@ -764,6 +764,14 @@ impl HgConnectionBase for HgHttpConnection {
     fn get_capability(&self, name: &[u8]) -> Option<&BStr> {
         self.capabilities.get_capability(name)
     }
+
+    fn sample_size(&self) -> usize {
+        if self.capabilities.get_capability(b"httppostargs").is_some() {
+            10000
+        } else {
+            100
+        }
+    }
 }
 
 impl Drop for HgHttpConnection {

src/hg_connect_stdio.rs

@@ -147,6 +147,10 @@ impl HgConnectionBase for HgStdioConnection {
     fn get_capability(&self, name: &[u8]) -> Option<&BStr> {
         self.capabilities.get_capability(name)
     }
+
+    fn sample_size(&self) -> usize {
+        10000
+    }
 }
 
 impl Drop for HgStdioConnection {

src/main.rs

@@ -539,7 +539,7 @@ fn do_fetch(store: &mut Store, remote: &OsStr, revs: &[OsString]) -> Result<(),
     let unknown = revs
         .iter()
         .filter_map(|r| r.left())
-        .chunks(hg_connect::SAMPLE_SIZE)
+        .chunks(conn.sample_size())
         .into_iter()
         .find_map(|chunk| {
             let chunk = chunk.collect_vec();
@@ -1065,7 +1065,7 @@ fn do_reclone(store: &mut Store, rebase: bool) -> Result<(), String> {
             let mut conn = get_connection(&url).unwrap();
 
             let knowns = unknowns
-                .chunks(hg_connect::SAMPLE_SIZE)
+                .chunks(conn.sample_size())
                 .map(|unknowns| {
                     conn.known(&unknowns.iter().map(|(_, csid)| *csid).collect_vec())
                         .into_vec()