Rollup merge of #23847 - bcoopers:read_clarification, r=sfackler

This introduces no functional changes except for reducing a few unnecessary operations and variables.  Vec has the behavior that, if you request space past the capacity with reserve(), it will round up to the nearest power of 2.  What that effectively means is that after the first call to reserve(16), we are doubling our capacity every time.  So using the DEFAULT_BUF_SIZE and doubling cap_size() here is meaningless and has no effect on the call to reserve().

Note that with #23842 implemented this will hopefully have a clearer API and less of a need for commenting.  If #23842 is not implemented then the most clear implementation would be to call reserve_exact(buf.capacity()) at every step (and making sure that buf.capacity() is not zero at the beginning of the function of course).

Edit- functional change now introduced.  We will now zero 16 bytes of the vector first, then double to 32, then 64, etc. until we read 64kB.  This stops us from zeroing the entire vector when we double it, some of which may be wasted work.  Reallocation still follows the doubling strategy, but the responsibility has been moved to vec.extend(), which calls reserve() and push_back().

src/libstd/io/mod.rs

@@ -101,18 +101,14 @@ fn drop(&mut self) {
 fn read_to_end<R: Read + ?Sized>(r: &mut R, buf: &mut Vec<u8>) -> Result<usize> {
     let start_len = buf.len();
     let mut len = start_len;
-    let mut cap_bump = 16;
+    let mut new_write_size = 16;
     let ret;
     loop {
         if len == buf.len() {
-            if buf.capacity() == buf.len() {
+            if new_write_size < DEFAULT_BUF_SIZE {
-                if cap_bump < DEFAULT_BUF_SIZE {
+                new_write_size *= 2;
-                    cap_bump *= 2;
-                }
-                buf.reserve(cap_bump);
             }
-            let new_area = buf.capacity() - buf.len();
+            buf.extend(iter::repeat(0).take(new_write_size));
-            buf.extend(iter::repeat(0).take(new_area));
         }
 
         match r.read(&mut buf[len..]) {